@appaflytech/zeyrek-ai-mcp 0.0.1

package/dist/knowledge/rules.js

@@ -0,0 +1,1725 @@
+import { reservedTenantTables } from './reservedTables.js';
+const terminalStepTypes = new Set(['response', 'convert', 'revert', 'end']);
+const stepKindMatrix = {
+    start: ['workflow', 'automation', 'middleware'],
+    condition: ['workflow', 'automation', 'middleware'],
+    code: ['workflow', 'automation', 'middleware'],
+    loop: ['workflow', 'automation', 'middleware'],
+    table: ['workflow', 'automation', 'middleware'],
+    query: ['workflow', 'automation', 'middleware'],
+    http: ['workflow', 'automation', 'middleware'],
+    workflow: ['workflow', 'automation', 'middleware'],
+    email: ['workflow', 'automation', 'middleware'],
+    'file-upload': ['workflow', 'automation', 'middleware'],
+    variable: ['middleware'],
+    'set-user': ['middleware'],
+    setcookie: ['middleware'],
+    redirect: ['middleware'],
+    response: ['workflow', 'middleware'],
+    convert: ['workflow'],
+    revert: ['automation'],
+    end: ['workflow', 'automation', 'middleware']
+};
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function workflowBody(definition, kind) {
+    if (kind === 'automation' && definition.automation && typeof definition.automation === 'object') {
+        const automationBody = definition.automation;
+        const automationSteps = asArray(automationBody.steps);
+        return automationSteps.length > 0 ? automationBody : { ...automationBody, steps: definition.steps };
+    }
+    return definition;
+}
+function workflowSteps(definition) {
+    return asArray(definition.steps).filter((step) => Boolean(step) && typeof step === 'object');
+}
+function stepLabel(step) {
+    return step.name || step.type || step.id || '?';
+}
+/**
+ * "Guard'lı mı?" sorusunun tek doğru cevabı YAZIM BİÇİMİ DEĞİL, SIRA: kökün kendisine (üye
+ * erişimi olmadan) bir kez dokunulduğu an — `Page.user &&`, `Page.user || {}`, `!Page.user`,
+ * `typeof Page.user`, `Page.user?.` — ifade guard'lanmıştır. Eski kural yalnız
+ * `Page.user && Page.user.x` kalıbını tanıyordu ve araya parantez giren
+ * `(Page.user && (Page.user.roles_csv || ''))` — rehberin KENDİ önerdiği yazım — yanlış pozitif
+ * üretiyordu (crm koşumu B-13). Guard'dan ÖNCE gelen üye erişimi hâlâ bulgudur.
+ */
+export function readsBeforeGuard(source, root) {
+    const escaped = root.replace(/\./g, '\\.');
+    const guardIndex = source.search(new RegExp(`${escaped}(?!\\s*\\.)`));
+    const limit = guardIndex === -1 ? Number.POSITIVE_INFINITY : guardIndex;
+    return [...source.matchAll(new RegExp(`${escaped}\\s*\\.\\s*[A-Za-z_]`, 'g'))].some(match => match.index < limit);
+}
+/**
+ * Sayfa akışında dal ADI bir etikettir, motorun anahtarıdır: Runtime.svelte:329 branch.id'yi
+ * branch.name'den üretir, task'lar `engine.next('always')` çağırır (start.ts:4, setter.ts:258,
+ * code.ts:49). Eşleşme yoksa flow-engine.ts:79 sessizce durur. Studio tarafında da zincir
+ * `sourceBranch === 'always'` ile çizilir (EventActionsStart.svelte:47, EventActionsItem.svelte:298).
+ * condition dalları rule id'sidir (serbest), microservice'te 'success' yalnız eski şema için
+ * yaşatılır (microservice.ts:144).
+ */
+const flowBranchNames = {
+    start: ['always'],
+    microservice: ['always', 'success'],
+    confirm: ['yes', 'no', 'always'],
+    end: []
+};
+const flowFreeBranchTypes = new Set(['condition']);
+const flowSetterIterateeTypes = new Set(['change', 'fill']);
+function flowStepList(value) {
+    return asArray(value).filter((step) => Boolean(step) && typeof step === 'object');
+}
+function flowAllSteps(definition) {
+    return [...flowStepList(definition.steps), ...flowStepList(definition.errorSteps)];
+}
+function flowStepLabel(step) {
+    return step.stepId || step.name || step.type || '?';
+}
+function flowBranches(step) {
+    return asArray(step.branches).filter((branch) => Boolean(branch) && typeof branch === 'object');
+}
+function flowIteratees(step) {
+    return asArray((step.args ?? {}).iteratees).filter((iteratee) => Boolean(iteratee) && typeof iteratee === 'object');
+}
+function flowValueOf(iteratee) {
+    return (iteratee.value ?? {});
+}
+function flowMappingOf(iteratee) {
+    return (iteratee.mapping ?? {});
+}
+function flowMappingsOf(iteratee) {
+    const mappings = flowMappingOf(iteratee).mappings;
+    return Boolean(mappings) && typeof mappings === 'object' && !Array.isArray(mappings) ? mappings : {};
+}
+/**
+ * setter.ts:161 — storage dalında `mapping.source` doluysa storage anahtarı ODUR ve `value.ref`
+ * hiç okunmaz (Studio'nun ürettiği şekil budur: mapping.source dolu, value.ref boş). Ref
+ * denetimleri bu yüzden ikisinden hangisi kullanılacaksa onun üzerinden yürümelidir.
+ */
+function flowStorageReference(iteratee) {
+    const mappingSource = flowMappingOf(iteratee).source;
+    if (typeof mappingSource === 'string' && mappingSource.length > 0)
+        return { reference: mappingSource, origin: 'mapping.source' };
+    const reference = flowValueOf(iteratee).ref;
+    return { reference: typeof reference === 'string' ? reference : '', origin: 'value.ref' };
+}
+/** Storage anahtarı adımın ADIdır (microservice.ts:89 `machine.setStorage(task.name, …)`), stepId değil. */
+function flowStorageRoot(reference) {
+    return typeof reference === 'string' ? reference.split('.')[0] ?? '' : '';
+}
+/**
+ * Akıştaki bütün JS ifadeleri: code adımının gövdesi (code.ts:18 `task.argument.value`), setter
+ * iteratee'sinin `value.type='code'` ref'i (setter.ts:193), mapping satırlarının kod ref'leri
+ * (setter.ts:91) ve microservice parametrelerinin kod ref'leri (microservice.ts:248). Hepsi aynı
+ * `runCode` sandbox'ında koşar.
+ */
+function flowCodeExpressions(step) {
+    const args = (step.args ?? {});
+    const expressions = [];
+    if (step.type === 'code' && typeof args.value === 'string')
+        expressions.push({ expression: args.value, origin: 'args.value' });
+    for (const iteratee of flowIteratees(step)) {
+        const value = flowValueOf(iteratee);
+        const target = `${String(iteratee.element ?? '?')}.${String(iteratee.property ?? '?')}`;
+        if (value.type === 'code' && typeof value.ref === 'string')
+            expressions.push({ expression: value.ref, origin: `iteratees['${target}'].value.ref` });
+        for (const [key, mapping] of Object.entries(flowMappingsOf(iteratee))) {
+            const mappingValue = (mapping ?? {});
+            if (mappingValue.type === 'code' && typeof mappingValue.ref === 'string') {
+                expressions.push({ expression: mappingValue.ref, origin: `mapping.mappings['${key}']` });
+            }
+        }
+    }
+    for (const parameter of asArray(args.parameters).filter((parameter) => Boolean(parameter) && typeof parameter === 'object')) {
+        const value = (parameter.value ?? {});
+        if (value.type === 'code' && typeof value.ref === 'string')
+            expressions.push({ expression: value.ref, origin: `parameters['${String(parameter.name ?? '?')}']` });
+    }
+    return expressions;
+}
+/** `Steps.ad.headers` / `Steps["ad"].headers` yakalar, `Steps.ad?.headers` guard'lısını yakalamaz. */
+const flowHeadersAccess = /Steps\s*(?:\.\s*([A-Za-z_$][\w$]*)|\[\s*['"]([^'"]+)['"]\s*\])\s*\.\s*headers\b/g;
+const writeOperations = new Set(['create', 'update', 'delete', 'upsert']);
+const filterOperators = new Set(['eq', 'neq', 'lt', 'lte', 'gt', 'gte', 'contains', 'icontains', 'in', 'notin', 'startswith', 'endswith', 'istartswith', 'iendswith']);
+function flattenFilterTree(filters) {
+    return filters
+        .filter((filter) => Boolean(filter) && typeof filter === 'object')
+        .flatMap(filter => [filter, ...flattenFilterTree(asArray(filter.children))]);
+}
+function unknownOperatorFindings(ruleId, owner, filters) {
+    const unknownOperators = flattenFilterTree(filters)
+        .filter(filter => filter.operator !== undefined && filter.operator !== null && !filterOperators.has(String(filter.operator).toLowerCase()))
+        .map(filter => `${String(filter.fieldSlug ?? filter.fieldId ?? '?')}: '${String(filter.operator)}'`);
+    return unknownOperators.length > 0
+        ? [{
+                ruleId,
+                severity: 'block',
+                message: `${owner}: bilinmeyen filtre operatörü — ${unknownOperators.join(', ')}. Platform bilinmeyen operatörü 400 ile REDDETMEZ, sessizce 'eq'e düşürür (EnumExtensions.GetValueFromDescription null → default) ve uç testten geçip yanlış çalışır. Geçerli sözlük: ${[...filterOperators].join(' · ')} ('like' yok — metin araması için 'contains'/'icontains').`,
+                guide: 'ngapps://guides/microservice'
+            }]
+        : [];
+}
+function isReadOperation(parameters) {
+    const operation = String(parameters?.operation ?? '').toLowerCase();
+    return !writeOperations.has(operation);
+}
+function isFileField(field) {
+    return String(field.dbType ?? '') === 'FILE' || String(field.commonType ?? '').toLowerCase().includes('file');
+}
+/**
+ * Çok değerli enum'un rehberde belgelenen (ve canlı doğrulanan) şekli: `VARCHAR` + `many-to-many` +
+ * `valueOptions`, `relationId` VERİLMEZ — platform enum değerleri için kendi junction/değer
+ * entity'sini üretir ve `relationMetadata.enumValuesEntityId`'yi kendisi doldurur. ENT-001 bunu
+ * "ilişki alanı yanlış kurulmuş" diye üç kez uyardı (etkinlik turu H5); yanlış pozitifler gerçek
+ * uyarıları gölgelediği için FILE alanlarındaki muafiyetin (G-02) ikizi olarak burada da muaf.
+ */
+function isMultiEnumField(field) {
+    const valueOptions = asArray(field.valueOptions);
+    return valueOptions.length > 0 || field.isEnum === true;
+}
+export function isJunctionField(field) {
+    const relationType = String(field.relationType ?? '');
+    const commonType = String(field.commonType ?? '');
+    return relationType === 'many-to-many' || commonType === 'multiRelation' || commonType === 'multiFile' || commonType === 'multiArray';
+}
+function tableSelectionFindings(ruleId, owner, parameters, guide) {
+    if (!parameters)
+        return [];
+    const joins = asArray(parameters.joins);
+    const selectFields = asArray(parameters.selectFields);
+    if (joins.length > 0 && selectFields.length === 0) {
+        return [{
+                ruleId,
+                severity: 'block',
+                message: `${owner}: join tanımlı ama selectFields boş — boş bırakmak TÜM alanları döndürür ve join'li sorguda maliyeti katlar. Yalnız ihtiyaç duyulan alanları selectFields'a ekleyin (TableSelect: { alias, fieldId, path, fieldSlug }).`,
+                guide
+            }];
+    }
+    if (selectFields.length === 0 && String(parameters.operation ?? '').toLowerCase() !== 'delete') {
+        return [{
+                ruleId,
+                severity: 'warn',
+                message: `${owner}: selectFields boş — tüm alanlar dönecek. Bilinçli değilse yalnız ihtiyaç duyulan alanları seçin.`,
+                guide
+            }];
+    }
+    return [];
+}
+export const policyRules = [
+    {
+        id: 'MS-001',
+        module: 'microservice',
+        appliesTo: ['create', 'update', 'preview'],
+        sourceRef: 'KAPI testi; CreateMicroserviceCommand.sourceParameters (selectFields/joins). Yalnız okuma operasyonlarında (get/count/boş): write yolunda platform selectFields\'i zaten yok sayar — TableMicroserviceExecutor.ByCreateAsync:215 (klinik K-003/K-007)',
+        check: definition => {
+            const parameters = definition.sourceParameters;
+            if (!isReadOperation(parameters))
+                return [];
+            if (definition.source === 'table') {
+                return tableSelectionFindings('MS-001', 'sourceParameters', parameters, 'ngapps://guides/microservice');
+            }
+            if (definition.source === 'view') {
+                return tableSelectionFindings('MS-001', 'sourceParameters (view)', parameters, 'ngapps://guides/microservice')
+                    .map(finding => ({ ...finding, severity: 'warn', message: `${finding.message} [view source canlı testte doğrulanmadı — warn]` }));
+            }
+            return [];
+        }
+    },
+    {
+        id: 'MS-002',
+        module: 'microservice',
+        appliesTo: ['create', 'update', 'preview'],
+        sourceRef: 'KAPI testi; source enum query|table|workflow|view',
+        check: definition => definition.source === 'query'
+            ? [{
+                    ruleId: 'MS-002',
+                    severity: 'warn',
+                    message: "source='query' seçildi: table kaynağı, query'nin yapabildiği neredeyse her şeyi platform-native yapar (filtre, join, sıralama, alan seçimi). Ham SQL gerçekten şartsa devam edin; değilse source='table' kullanın.",
+                    guide: 'ngapps://guides/microservice'
+                }]
+            : []
+    },
+    {
+        id: 'WF-001',
+        module: 'workflow',
+        appliesTo: ['create', 'update'],
+        sourceRef: 'KAPI testi; StepDto.branches[].nextStepId; Steps/IStep.cs StepOutput.BranchId',
+        check: (definition, context) => {
+            const body = workflowBody(definition, context.workflowKind);
+            const steps = workflowSteps(body);
+            if (steps.length === 0) {
+                return [{ ruleId: 'WF-001', severity: 'block', message: 'steps boş — en az bir start step\'i ve ona bağlı akış gerekir.', guide: 'ngapps://guides/workflow' }];
+            }
+            const startStep = steps.find(step => step.type === 'start');
+            if (!startStep) {
+                return [{ ruleId: 'WF-001', severity: 'block', message: "type='start' step'i yok — her akış start ile başlar.", guide: 'ngapps://guides/workflow' }];
+            }
+            const stepsById = new Map(steps.filter(step => step.id).map(step => [String(step.id), step]));
+            const reached = new Set();
+            const queue = [String(startStep.id ?? '')];
+            while (queue.length > 0) {
+                const currentId = queue.pop();
+                if (!currentId || reached.has(currentId))
+                    continue;
+                reached.add(currentId);
+                for (const branch of asArray(stepsById.get(currentId)?.branches)) {
+                    if (branch?.nextStepId)
+                        queue.push(String(branch.nextStepId));
+                }
+            }
+            const unreachable = steps.filter(step => step.id && !reached.has(String(step.id)));
+            if (unreachable.length > 0) {
+                return [{
+                        ruleId: 'WF-001',
+                        severity: 'block',
+                        message: `Start'tan erişilemeyen step'ler var: ${unreachable.map(stepLabel).join(', ')}. Step'ler branches[].nextStepId ile bağlanır — önceki step'in uygun branch'ine (success/fail/else) bu step'lerin id'sini yazın.`,
+                        guide: 'ngapps://guides/workflow'
+                    }];
+            }
+            return [];
+        }
+    },
+    {
+        id: 'WF-002',
+        module: 'workflow',
+        appliesTo: ['create', 'update'],
+        sourceRef: 'KAPI testi; iş kuralı: workflow tipinde ReturnDto zorunlu (automation/middleware muaf)',
+        check: (definition, context) => {
+            const body = workflowBody(definition, context.workflowKind);
+            const kind = context.workflowKind ?? body.type;
+            if (kind === 'workflow' && !body.returnDtoId) {
+                return [{
+                        ruleId: 'WF-002',
+                        severity: 'block',
+                        message: "type='workflow' için returnDtoId zorunludur (backend nullable bırakır ama iş kuralı zorunlu; automation ve middleware muaftır). Önce DataTransferObject oluşturup id'sini returnDtoId'ye verin.",
+                        guide: 'ngapps://guides/workflow'
+                    }];
+            }
+            return [];
+        }
+    },
+    {
+        id: 'WF-003',
+        module: 'workflow',
+        appliesTo: ['create', 'update', 'preview'],
+        sourceRef: 'DTO-önce akışı; WorkflowTableForm input.name placeholder\'ları',
+        check: (definition, context) => {
+            const body = workflowBody(definition, context.workflowKind);
+            if (!body.parameterDtoId && JSON.stringify(body.steps ?? '').includes('input.')) {
+                return [{
+                        ruleId: 'WF-003',
+                        severity: 'warn',
+                        message: "Step'lerde 'input.' referansı var ama parameterDtoId tanımlı değil — girdiler DataTransferObject ile tanımlanmalı ki input.<alan> referansları bir şeye bağlansın.",
+                        guide: 'ngapps://guides/workflow'
+                    }];
+            }
+            return [];
+        }
+    },
+    {
+        id: 'WF-004',
+        module: 'workflow',
+        appliesTo: ['create', 'update'],
+        sourceRef: 'UI WORKFLOW_STEPS: Response modülleri workflow+middleware',
+        check: (definition, context) => {
+            const body = workflowBody(definition, context.workflowKind);
+            const kind = context.workflowKind ?? body.type;
+            if (kind === 'workflow' && !workflowSteps(body).some(step => step.type === 'response')) {
+                return [{
+                        ruleId: 'WF-004',
+                        severity: 'warn',
+                        message: "type='workflow' ama response step'i yok — akış yanıt döndürmeyecek. Bilinçli değilse akışın sonuna response step'i bağlayın.",
+                        guide: 'ngapps://guides/workflow'
+                    }];
+            }
+            return [];
+        }
+    },
+    {
+        id: 'WF-005',
+        module: 'workflow',
+        appliesTo: ['create', 'update', 'preview'],
+        sourceRef: 'NgApps.UI apps/studio features/workflow/workflow.constants.ts WORKFLOW_STEPS[].modules',
+        check: (definition, context) => {
+            const body = workflowBody(definition, context.workflowKind);
+            const kind = context.workflowKind ?? body.type;
+            if (!kind)
+                return [];
+            return workflowSteps(body)
+                .filter(step => {
+                const allowedKinds = stepKindMatrix[String(step.type)];
+                return allowedKinds && !allowedKinds.includes(kind);
+            })
+                .map(step => ({
+                ruleId: 'WF-005',
+                severity: 'block',
+                message: `'${stepLabel(step)}' step'i (${step.type}) ${kind} tipinde kullanılamaz. İzin matrisi: variable/set-user/setcookie/redirect yalnız middleware; convert yalnız workflow; revert yalnız automation; response workflow+middleware.`,
+                guide: 'ngapps://guides/workflow'
+            }));
+        }
+    },
+    {
+        id: 'WF-006',
+        module: 'workflow',
+        appliesTo: ['create', 'update'],
+        sourceRef: 'UI WORKFLOW_STEPS: terminal step\'lerde branches boş, diğerlerinde success/fail',
+        check: (definition, context) => {
+            const body = workflowBody(definition, context.workflowKind);
+            const findings = [];
+            for (const step of workflowSteps(body)) {
+                const branches = asArray(step.branches);
+                if (terminalStepTypes.has(String(step.type)) && branches.length > 0) {
+                    findings.push({
+                        ruleId: 'WF-006',
+                        severity: 'warn',
+                        message: `'${stepLabel(step)}' (${step.type}) terminal bir step — branch taşımamalı.`,
+                        guide: 'ngapps://guides/workflow'
+                    });
+                }
+                if (!terminalStepTypes.has(String(step.type)) && step.type !== 'start' && branches.length === 0) {
+                    findings.push({
+                        ruleId: 'WF-006',
+                        severity: 'warn',
+                        message: `'${stepLabel(step)}' (${step.type}) step'inin hiç branch'i yok — success/fail branch'leri tanımlayıp nextStepId bağlayın, yoksa akış burada kopar.`,
+                        guide: 'ngapps://guides/workflow'
+                    });
+                }
+            }
+            return findings;
+        }
+    },
+    {
+        id: 'WF-007',
+        module: 'workflow',
+        appliesTo: ['create', 'update', 'preview'],
+        sourceRef: 'MS-001 kuralının workflow table step karşılığı; StepDto.rule.selectFields/joins. Yalnız okuma operasyonlarında — write step\'te platform selectFields\'i yok sayar, çıktı returnFields\'tır (TableMicroserviceExecutor.ByCreateAsync:215; klinikrandevu 2. tur H-002)',
+        check: (definition, context) => {
+            const body = workflowBody(definition, context.workflowKind);
+            return workflowSteps(body)
+                .filter(step => step.type === 'table' && isReadOperation(step.rule))
+                .flatMap(step => tableSelectionFindings('WF-007', `'${stepLabel(step)}' table step'i (rule)`, step.rule, 'ngapps://guides/workflow')
+                .map(finding => ({ ...finding, severity: 'warn' })));
+        }
+    },
+    {
+        id: 'WF-008',
+        module: 'workflow',
+        appliesTo: ['create', 'update', 'preview'],
+        sourceRef: 'KAPI testi; MS-002 kuralının step karşılığı',
+        check: (definition, context) => {
+            const body = workflowBody(definition, context.workflowKind);
+            const queryStepNames = workflowSteps(body).filter(step => step.type === 'query').map(stepLabel);
+            return queryStepNames.length > 0
+                ? [{
+                        ruleId: 'WF-008',
+                        severity: 'warn',
+                        message: `Query step kullanılmış (${queryStepNames.join(', ')}): table step, query'nin yapabildiği neredeyse her şeyi platform-native yapar. Ham SQL şart değilse table step kullanın.`,
+                        guide: 'ngapps://guides/workflow'
+                    }]
+                : [];
+        }
+    },
+    {
+        id: 'WF-010',
+        module: 'workflow',
+        appliesTo: ['create', 'update'],
+        sourceRef: 'WorkflowRepository.FindAutomationsByEntityAsync: IsQueue==queued + Operation==type filtresi; null asla eşleşmez. state=unready automation için NORMALDİR (qm\'deki çalışan automation\'lar da unready; IsReady() hiçbir yerde çağrılmıyor)',
+        check: (definition, context) => {
+            if (context.workflowKind !== 'automation')
+                return [];
+            const automationSettings = (definition.automation ?? {});
+            const findings = [];
+            if (automationSettings.isQueue === undefined || automationSettings.isQueue === null) {
+                findings.push({
+                    ruleId: 'WF-010',
+                    severity: 'block',
+                    message: "automation.isQueue verilmedi — tetikleme sorgusu IsQueue == false/true ile filtreler, null HİÇBİR ZAMAN eşleşmez ve automation sessizce ölü kalır. Anlık çalışma için isQueue: false, kuyruklu için true verin.",
+                    guide: 'ngapps://guides/workflow'
+                });
+            }
+            if (!automationSettings.operation) {
+                findings.push({
+                    ruleId: 'WF-010',
+                    severity: 'block',
+                    message: "automation.operation verilmedi (create | update | delete ...) — tetikleme sorgusu Operation üzerinden eşleşir, boş bırakılan automation tetiklenmez.",
+                    guide: 'ngapps://guides/workflow'
+                });
+            }
+            if (definition.returnDtoId || automationSettings.returnDtoId) {
+                findings.push({
+                    ruleId: 'WF-010',
+                    severity: 'block',
+                    message: "Automation'da returnDtoId YASAKTIR (platform validator: 'Return Dto Id' must be empty). state=unready görünmesi normaldir ve tetiklemeyi ETKİLEMEZ — returnDtoId atamaya çalışmayın.",
+                    guide: 'ngapps://guides/workflow'
+                });
+            }
+            return findings;
+        }
+    },
+    {
+        id: 'WF-011',
+        module: 'workflow',
+        appliesTo: ['create', 'update', 'preview'],
+        sourceRef: "hr günlüğü #10/#14: step/branch id'leri gerçek GUID olmalı (System.Guid çevrimi) ve DB'de satır oldukları için global benzersiz",
+        check: (definition, context) => {
+            const guidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+            const body = workflowBody(definition, context.workflowKind);
+            const invalidIds = workflowSteps(body)
+                .flatMap(step => [step.id, ...asArray(step.branches).map(branch => branch?.id)])
+                .filter(id => id !== undefined && id !== null && !guidPattern.test(String(id)));
+            return invalidIds.length > 0
+                ? [{
+                        ruleId: 'WF-011',
+                        severity: 'block',
+                        message: `Step/branch id'leri gerçek GUID olmalı; geçersiz: ${[...new Set(invalidIds.map(String))].join(', ')}. Ayrıca id'ler veritabanında satırdır — başka bir akıştaki GUID'i tekrar kullanmak RowAlreadyExists üretir, her akışa taze GUID'ler verin.`,
+                        guide: 'ngapps://guides/workflow'
+                    }]
+                : [];
+        }
+    },
+    {
+        id: 'WF-012',
+        module: 'workflow',
+        appliesTo: ['create', 'update', 'preview'],
+        sourceRef: "hr günlüğü #13: table step'te aynı alan hem fields hem selectFields'ta olamaz (duplicate key)",
+        check: (definition, context) => {
+            const body = workflowBody(definition, context.workflowKind);
+            return workflowSteps(body)
+                .filter(step => step.type === 'table' && step.rule)
+                .flatMap(step => {
+                const writeSlugs = new Set(asArray(step.rule.fields)
+                    .filter((field) => Boolean(field) && typeof field === 'object')
+                    .map(field => String(field.fieldSlug ?? field.slug ?? '')));
+                const overlapping = asArray(step.rule.selectFields)
+                    .filter((field) => Boolean(field) && typeof field === 'object')
+                    .map(field => String(field.fieldSlug ?? field.slug ?? ''))
+                    .filter(slug => slug.length > 0 && writeSlugs.has(slug));
+                return overlapping.length > 0
+                    ? [{
+                            ruleId: 'WF-012',
+                            severity: 'warn',
+                            message: `'${stepLabel(step)}' table step'inde aynı alan hem fields (yazılacak) hem selectFields (okunacak) içinde: ${overlapping.join(', ')} — platform 'An item with the same key has already been added' üretir; alanı birinden çıkarın.`,
+                            guide: 'ngapps://guides/workflow'
+                        }]
+                    : [];
+            });
+        }
+    },
+    {
+        id: 'MS-006',
+        module: 'microservice',
+        appliesTo: ['create', 'update', 'preview'],
+        sourceRef: "hr günlüğü #8, düzeltilmiş: selectFields[].fieldId zorunlu (kök datasourceId iddiası YANLIŞTI — CreateMicroserviceCommand'da öyle bir property yok, STJ yok sayar); eksik fieldId'yi platform validator'ı artık 400 ile erken yakalar",
+        check: definition => {
+            if (definition.source !== 'table')
+                return [];
+            const findings = [];
+            const parameters = (definition.sourceParameters ?? {});
+            const missingFieldIds = asArray(parameters.selectFields)
+                .filter((entry) => Boolean(entry) && typeof entry === 'object')
+                .filter(entry => !entry.fieldId)
+                .map(entry => String(entry.fieldSlug ?? '?'));
+            if (missingFieldIds.length > 0) {
+                findings.push({
+                    ruleId: 'MS-006',
+                    severity: 'block',
+                    message: `selectFields'ta fieldId eksik (yalnız fieldSlug yetmez): ${missingFieldIds.join(', ')}. Alan id'lerini entity_get view:'outline' çıktısından alın.`,
+                    guide: 'ngapps://guides/microservice'
+                });
+            }
+            return findings;
+        }
+    },
+    {
+        id: 'AUT-001',
+        module: 'workflow',
+        appliesTo: ['create', 'update'],
+        sourceRef: 'ik-hrm teslim notu PLT-007 (hr\'de teyit): steps hem üst seviyede hem automation içinde verilmeli',
+        check: (definition, context) => {
+            if (context.workflowKind !== 'automation' || !definition.automation || typeof definition.automation !== 'object')
+                return [];
+            const topLevelCount = asArray(definition.steps).length;
+            const nestedCount = asArray(definition.automation.steps).length;
+            if (nestedCount > 0 && topLevelCount === 0) {
+                return [{
+                        ruleId: 'AUT-001',
+                        severity: 'warn',
+                        message: "steps yalnız 'automation' nesnesinin içinde — platform üst seviyedeki steps'i okur. steps dizisini hem üst seviyeye hem automation içine koyun (PLT-007).",
+                        guide: 'ngapps://guides/workflow'
+                    }];
+            }
+            if (topLevelCount > 0 && nestedCount === 0) {
+                return [{
+                        ruleId: 'AUT-001',
+                        severity: 'warn',
+                        message: "steps yalnız üst seviyede — aynı steps dizisini 'automation' nesnesinin içine de koyun (PLT-007: iki seviyede birden gerekir).",
+                        guide: 'ngapps://guides/workflow'
+                    }];
+            }
+            return [];
+        }
+    },
+    {
+        id: 'MS-004',
+        module: 'microservice',
+        appliesTo: ['create', 'update', 'preview'],
+        sourceRef: 'ik-hrm teslim notu PLT-006: table source üst seviye entityId ister. View kaynağı MUAF (etkinlik turu, yanlış pozitif): MicroserviceService:519 view entity\'lerini ViewId üzerinden çözer, entityId beklemez — onun karşılığı viewId',
+        check: definition => {
+            if (definition.source === 'table' && !definition.entityId) {
+                return [{
+                        ruleId: 'MS-004',
+                        severity: 'warn',
+                        message: "source='table' için üst seviye 'entityId' de zorunludur (sourceParameters.entityId tek başına yetmez).",
+                        guide: 'ngapps://guides/microservice'
+                    }];
+            }
+            if (definition.source === 'view' && !definition.viewId) {
+                return [{
+                        ruleId: 'MS-004',
+                        severity: 'warn',
+                        message: "source='view' ucu entity'leri VIEW'den çözer (MicroserviceService:519 `viewService.GetAsync(microservice.ViewId)` → view.Tables); üst seviye 'entityId' değil **viewId** zorunludur.",
+                        guide: 'ngapps://guides/microservice'
+                    }];
+            }
+            return [];
+        }
+    },
+    {
+        id: 'MS-005',
+        module: 'microservice',
+        appliesTo: ['create', 'update', 'preview'],
+        sourceRef: 'PostgreSqlRelationHandler.HandleSelect: alias\'sız join/select TryAdd(null)/GetValueOrDefault(null) ile 500 "null key" üretir; yalnız table source (view alias düzeni farklı, test edilmedi)',
+        check: definition => {
+            if (definition.source !== 'table')
+                return [];
+            const parameters = definition.sourceParameters;
+            if (!parameters)
+                return [];
+            const findings = [];
+            const flattenJoins = (joins) => joins
+                .filter((join) => Boolean(join) && typeof join === 'object')
+                .flatMap(join => [join, ...flattenJoins(asArray(join.joins))]);
+            const allJoins = flattenJoins(asArray(parameters.joins));
+            for (const join of allJoins) {
+                const missing = ['alias', 'entityId', 'fieldId'].filter(key => !join[key]);
+                if (missing.length > 0) {
+                    findings.push({
+                        ruleId: 'MS-005',
+                        severity: 'block',
+                        message: `Join tanımında zorunlu alan eksik (${missing.join(', ')}): ${JSON.stringify({ alias: join.alias, path: join.path })}. Alias'sız join platformda 500 'null key' (ArgumentNullException) üretir — bug değil, doğrulanmayan girdi.`,
+                        guide: 'ngapps://guides/microservice'
+                    });
+                }
+            }
+            const joinAliases = allJoins.map(join => String(join.alias ?? '')).filter(alias => alias.length > 0);
+            if (new Set(joinAliases).size !== joinAliases.length) {
+                findings.push({
+                    ruleId: 'MS-005',
+                    severity: 'block',
+                    message: `Join alias'ları benzersiz olmalı: ${joinAliases.join(', ')}. Aynı alias sessizce ilk join'e eşlenir (TryAdd) ve diğer join'in alanları yanlış tabloya bağlanır — hata bile alınmaz.`,
+                    guide: 'ngapps://guides/microservice'
+                });
+            }
+            const validAliases = new Set([String(parameters.alias ?? ''), ...joinAliases].filter(alias => alias.length > 0));
+            for (const select of asArray(parameters.selectFields).filter((entry) => Boolean(entry) && typeof entry === 'object')) {
+                const selectAlias = String(select.alias ?? '');
+                if (selectAlias.length === 0) {
+                    findings.push({
+                        ruleId: 'MS-005',
+                        severity: 'block',
+                        message: `selectFields[${select.fieldSlug ?? select.fieldId ?? '?'}] alias'sız — ana tablo alanları için alias = entity slug'ı (${parameters.alias ?? '<sourceParameters.alias>'}) ve path: '' kullanın.`,
+                        guide: 'ngapps://guides/microservice'
+                    });
+                }
+                else if (validAliases.size > 0 && !validAliases.has(selectAlias)) {
+                    findings.push({
+                        ruleId: 'MS-005',
+                        severity: 'block',
+                        message: `selectFields[${select.fieldSlug ?? select.fieldId ?? '?'}] alias'ı '${selectAlias}' tanımlı değil — geçerli alias'lar: ${[...validAliases].join(', ')}. Yanlış alias SQL'de 'missing FROM-clause entry' üretir.`,
+                        guide: 'ngapps://guides/microservice'
+                    });
+                }
+            }
+            return findings;
+        }
+    },
+    {
+        id: 'ENT-001',
+        module: 'entity',
+        appliesTo: ['create', 'update'],
+        sourceRef: "hr günlüğü #7 (DB doğrulaması: 57 ilişki alanı): doğru şekil dbType 'RELATION' + commonType 'relation' + relationId; relation alt nesnesini platform kendisi doldurur. FILE alanları kapsam DIŞI: relationId verilmez, Files entity'sini platform bağlar (klinik K-007)",
+        check: definition => asArray(definition.fields)
+            .filter((field) => Boolean(field) && typeof field === 'object')
+            .flatMap(field => {
+            const relationType = String(field.relationType ?? 'none');
+            if (relationType === 'none' || relationType === 'None')
+                return [];
+            if (isFileField(field))
+                return [];
+            if (isMultiEnumField(field))
+                return [];
+            const findings = [];
+            if (!field.relationId) {
+                findings.push({
+                    ruleId: 'ENT-001',
+                    severity: 'warn',
+                    message: `'${field.name ?? field.slug ?? '?'}' alanında relationType='${field.relationType}' ama relationId boş — hedef entity'nin id'sini verin.`,
+                    guide: 'ngapps://guides/entity'
+                });
+            }
+            if (field.dbType !== undefined && field.dbType !== 'RELATION') {
+                findings.push({
+                    ruleId: 'ENT-001',
+                    severity: 'warn',
+                    message: `'${field.name ?? field.slug ?? '?'}' ilişki alanında dbType='${field.dbType}' — ilişki alanının doğru şekli dbType: 'RELATION' + commonType: 'relation'; relation alt nesnesini (primaryKeyId vb.) platform kendisi doldurur, elle vermeyin.`,
+                    guide: 'ngapps://guides/entity'
+                });
+            }
+            if (field.commonType !== undefined && field.commonType !== 'relation') {
+                findings.push({
+                    ruleId: 'ENT-001',
+                    severity: 'warn',
+                    message: `'${field.name ?? field.slug ?? '?'}' ilişki alanında commonType='${field.commonType}' — 'relation' olmalı.`,
+                    guide: 'ngapps://guides/entity'
+                });
+            }
+            return findings;
+        })
+    },
+    {
+        id: 'ENT-002',
+        module: 'entity',
+        appliesTo: ['create'],
+        sourceRef: 'sms oturumu (2026-08-15) — eski PLT-004 iddiası ÇÜRÜTÜLDÜ: bağsız entity\'de row_create/row_list sorunsuz çalışıyor (16 satırlık bağsız grades tablosunda doğrulandı). Bağın gerçek etkisi: EntityRepository.cs:167 entity_list applicationId filtresi (Studio\'nun application entity listesi) ve MicroserviceRepository.cs:556 bağımlılık sorgusu. Auto page ise EntityApplications\'a DEĞİL PageSettings\'e bakar (UpdatePageWhenEntityUpdatedEventHandler.cs:42) — sms\'te 7 bağsız entity, 0 page_settings, 0 auto page',
+        check: definition => asArray(definition.applicationIds).length === 0
+            ? [{
+                    ruleId: 'ENT-002',
+                    severity: 'warn',
+                    message: "applicationIds boş: satır uçları bundan ETKİLENMEZ (bağsız entity'de row_create/row_list çalışır), ama entity Studio'nun application bazlı entity listesinde görünmez. Studio'dan yönetilecekse applicationIds: ['<application id>'] verin; yalnız API'den kullanılacaksa boş bırakmak geçerli bir tercihtir.",
+                    guide: 'ngapps://guides/entity'
+                }]
+            : []
+    },
+    {
+        id: 'ENT-003',
+        module: 'entity',
+        appliesTo: ['create', 'update'],
+        sourceRef: "hr günlüğü #2-4 (probe ile saptandı, DB doğrulandı): tip listesi BÜYÜK HARF ve ondalık tip yok. 'Incremental' PostgreSqlConnector.cs'te ayrı bir DataTypeGroup'tur (fiziksel tip TEXT), destek masası koşumu B-10'da yanlış pozitif verdi",
+        check: definition => {
+            const allowedDbTypes = new Set(['UUID', 'VARCHAR', 'TEXT', 'BOOL', 'INT2', 'INT4', 'INT8', 'DATE', 'TIME', 'TIMESTAMP', 'TIMESTAMPTZ', 'JSONB', 'FILE', 'RELATION', 'Incremental']);
+            const findings = [];
+            for (const field of asArray(definition.fields).filter((entry) => Boolean(entry) && typeof entry === 'object')) {
+                if (field.dbType === undefined)
+                    continue;
+                const dbType = String(field.dbType);
+                if (allowedDbTypes.has(dbType))
+                    continue;
+                if (dbType.toLowerCase() === 'incremental') {
+                    findings.push({
+                        ruleId: 'ENT-003',
+                        severity: 'warn',
+                        message: `'${field.slug ?? field.name}' artan kod alanının dbType'ı tam olarak 'Incremental' yazılır (tek büyük harf), commonType 'incremental' olur.`,
+                        guide: 'ngapps://guides/entity'
+                    });
+                    continue;
+                }
+                if (allowedDbTypes.has(dbType.toUpperCase())) {
+                    findings.push({
+                        ruleId: 'ENT-003',
+                        severity: 'warn',
+                        message: `'${field.slug ?? field.name}' dbType='${dbType}' — kontrol büyük/küçük harfe duyarlı, '${dbType.toUpperCase()}' yazın.`,
+                        guide: 'ngapps://guides/entity'
+                    });
+                }
+                else {
+                    findings.push({
+                        ruleId: 'ENT-003',
+                        severity: 'warn',
+                        message: `'${field.slug ?? field.name}' dbType='${dbType}' desteklenmiyor. Geçerli tipler (BÜYÜK HARF): UUID, VARCHAR, TEXT, BOOL, INT2, INT4, INT8, DATE, TIME, TIMESTAMP, TIMESTAMPTZ, JSONB, FILE, RELATION — ayrıca sıralı insan-okuyabilir kod için 'Incremental' (commonType 'incremental'). Ondalık tip YOK (NUMERIC/FLOAT/MONEY/DECIMAL reddedilir) — para için INT8+kuruş, yüzde için INT4×100 gibi birim konvansiyonu kullanın ve birimi description'a yazın.`,
+                        guide: 'ngapps://guides/entity'
+                    });
+                }
+            }
+            return findings;
+        }
+    },
+    {
+        id: 'ENT-005',
+        module: 'entity',
+        appliesTo: ['create', 'update'],
+        sourceRef: "hr günlüğü #2: commonType olmadan UUID/BOOL çözümlenemiyor; eşleme qm projesinden çıkarıldı. TEXT+incremental çifti destek masası koşumu B-10'da yanlış pozitif verdi: platform kaydettikten sonra dbType'ı TEXT'e normalize eder, commonType 'incremental' kalır",
+        check: definition => {
+            const commonTypeByDbType = {
+                UUID: 'guid', VARCHAR: 'text', TEXT: 'text', BOOL: 'bool',
+                INT2: 'number', INT4: 'number', INT8: 'number',
+                DATE: 'date', TIME: 'time', TIMESTAMP: 'datetime', TIMESTAMPTZ: 'datetime',
+                JSONB: 'custom', FILE: 'file', RELATION: 'relation', Incremental: 'incremental'
+            };
+            const findings = [];
+            for (const field of asArray(definition.fields).filter((entry) => Boolean(entry) && typeof entry === 'object')) {
+                const dbType = String(field.dbType ?? '');
+                const expected = commonTypeByDbType[dbType];
+                if (!expected)
+                    continue;
+                if (field.commonType === 'incremental' && (dbType === 'TEXT' || dbType === 'VARCHAR' || dbType === 'Incremental'))
+                    continue;
+                if (field.commonType === undefined) {
+                    findings.push({
+                        ruleId: 'ENT-005',
+                        severity: 'warn',
+                        message: `'${field.slug ?? field.name}' alanında commonType eksik — dbType '${field.dbType}' için commonType: '${expected}' verin (commonType'sız bazı tipler 'isn't a supported database type' hatasıyla reddedilir).`,
+                        guide: 'ngapps://guides/entity'
+                    });
+                }
+                else if (field.commonType !== expected) {
+                    findings.push({
+                        ruleId: 'ENT-005',
+                        severity: 'warn',
+                        message: `'${field.slug ?? field.name}' alanında commonType='${field.commonType}' — dbType '${field.dbType}' için beklenen: '${expected}'.`,
+                        guide: 'ngapps://guides/entity'
+                    });
+                }
+            }
+            return findings;
+        }
+    },
+    {
+        id: 'ENT-009',
+        module: 'entity',
+        appliesTo: ['create'],
+        sourceRef: "SeedData.AddEntities her projeye users/roles/user_roles/permissions/role_permissions entity'lerini SABİT id'lerle açar (Defaults.UserEntityId = 01917ede-330e-7254-8544-eef0db3693af); users gerçek bir datastore entity'sidir (altın örnek middleware-authenticate onu okur) ama entity_list applicationId ile çağrılınca görünmez — seed EntityApplication kaydı açmaz. Bilgi amaçlı warn: karar ajana ait",
+        check: definition => {
+            const fields = asArray(definition.fields).filter((entry) => Boolean(entry) && typeof entry === 'object');
+            const slugs = fields.map(field => String(field.slug ?? field.name ?? '').toLowerCase());
+            const hasIdentifier = slugs.some(slug => /^(e[_-]?mail|email|kullanici_adi|username|user_name)$/.test(slug));
+            const hasSecret = slugs.some(slug => /^(password|parola|sifre|sifre_hash|password_hash|passwordhash)$/.test(slug));
+            if (!hasIdentifier || !hasSecret)
+                return [];
+            return [{
+                    ruleId: 'ENT-009',
+                    severity: 'warn',
+                    message: `'${definition.slug ?? definition.name ?? '?'}' entity'sinde hem kimlik (${slugs.filter(slug => /mail|user_?name|kullanici_adi/.test(slug)).join(', ')}) hem parola alanı var — İKİNCİ bir kimlik sistemi kuruyor olabilirsiniz. Platform her projeye hazır bir 'users' entity'si açar (sabit id 01917ede-330e-7254-8544-eef0db3693af; id/email/password/first_name/last_name, kendi DTO'su, auth middleware'inin okuduğu tablo) ve entity_list'i applicationId ile çağırdığınız için listede GÖRMEMİŞ olabilirsiniz — applicationId'siz çağırıp bakın. Kimlik alanlarını entity_patch ile users'a ekleyip domain verisini ayrı entity'de tutmak, roller/middlewareIds yetkilendirmesiyle konuşan tek bir kimlik bırakır. Bilerek ayrı bir kimlik kuruyorsanız (dış sistemle eşleşen hesaplar, users'a dokunulamayan senaryo) bu uyarıyı geçin. Ayrıntı: platform_guide('entity') §'Hazır entity'ler'.`,
+                    guide: 'ngapps://guides/entity'
+                }];
+        }
+    },
+    {
+        id: 'ENT-004',
+        module: 'entity',
+        appliesTo: ['create', 'update'],
+        sourceRef: 'ik-hrm teslim notu PLT-002: display alanı tekil',
+        check: definition => {
+            const displayFields = asArray(definition.fields)
+                .filter((field) => Boolean(field) && typeof field === 'object')
+                .filter(field => field.display === true);
+            return displayFields.length > 1
+                ? [{
+                        ruleId: 'ENT-004',
+                        severity: 'warn',
+                        message: `Birden çok display alanı var (${displayFields.map(field => field.slug ?? field.name).join(', ')}) — entity başına yalnız BİR display alanı olabilir.`,
+                        guide: 'ngapps://guides/entity'
+                    }]
+                : [];
+        }
+    },
+    {
+        id: 'MS-007',
+        module: 'microservice',
+        appliesTo: ['create', 'update', 'preview'],
+        sourceRef: 'sms oturumu: MicroserviceFormTableRelations.svelte seçili join alanlarını `item.path === getPath(relationFieldId)` ile bulur; MicroserviceFormTableFiltersItem join path\'inin ilk parçasını (kök entityId) atar. path boşken runtime ÇALIŞIR ama Studio hiçbir join alanını seçili gösteremez',
+        check: definition => {
+            if (definition.source !== 'table')
+                return [];
+            const parameters = definition.sourceParameters;
+            if (!parameters)
+                return [];
+            const rootEntityId = String(parameters.entityId ?? definition.entityId ?? '');
+            const findings = [];
+            const joinPaths = new Map();
+            const walk = (joins, chain) => {
+                for (const join of joins) {
+                    if (!join || typeof join !== 'object')
+                        continue;
+                    const entry = join;
+                    const alias = String(entry.alias ?? '');
+                    const nextChain = [...chain, String(entry.fieldId ?? '')];
+                    const expected = [rootEntityId, ...nextChain].join('.');
+                    if (!entry.path) {
+                        findings.push({
+                            ruleId: 'MS-007',
+                            severity: 'block',
+                            message: `'${alias}' join'inde 'path' boş. Beklenen: '${expected}' (kök entityId + ilişki alanı zinciri). Boş path'te sorgu çalışır ama Studio bu join'in alanlarını seçili gösteremez.`,
+                            guide: 'ngapps://guides/microservice'
+                        });
+                    }
+                    else if (String(entry.path) !== expected) {
+                        findings.push({
+                            ruleId: 'MS-007',
+                            severity: 'block',
+                            message: `'${alias}' join'inin path'i beklenenden farklı: '${entry.path}' ≠ '${expected}'.`,
+                            guide: 'ngapps://guides/microservice'
+                        });
+                    }
+                    if (alias)
+                        joinPaths.set(alias, nextChain.join('.'));
+                    walk(asArray(entry.joins), nextChain);
+                }
+            };
+            walk(asArray(parameters.joins), []);
+            if (joinPaths.size === 0)
+                return findings;
+            for (const list of [asArray(parameters.selectFields), asArray(parameters.returnFields)]) {
+                for (const entry of list) {
+                    if (!entry || typeof entry !== 'object')
+                        continue;
+                    const select = entry;
+                    const alias = String(select.alias ?? '');
+                    const expected = joinPaths.get(alias);
+                    if (expected === undefined)
+                        continue;
+                    if (String(select.path ?? '') !== expected) {
+                        findings.push({
+                            ruleId: 'MS-007',
+                            severity: 'block',
+                            message: `'${alias}' alias'lı seçili alanın ('${select.fieldSlug ?? select.fieldId}') path'i '${select.path ?? ''}' — join'li alanlarda path kök entityId OLMADAN ilişki alanı zinciri olmalı: '${expected}'.`,
+                            guide: 'ngapps://guides/microservice'
+                        });
+                    }
+                }
+            }
+            return findings;
+        }
+    },
+    {
+        id: 'MS-008',
+        module: 'microservice',
+        appliesTo: ['create', 'update', 'preview'],
+        sourceRef: 'sms oturumu: MicroserviceFormTableSortContent.svelte data.sort.name / data.sort.sortValue değerlerini guard\'sız okur; sort null olan kayıt Studio sayfasını TypeError ile komple düşürür',
+        check: definition => {
+            if (definition.source !== 'table')
+                return [];
+            const parameters = definition.sourceParameters;
+            if (!parameters)
+                return [];
+            const missing = ['sort', 'limit'].filter(key => !parameters[key]);
+            return missing.length > 0
+                ? [{
+                        ruleId: 'MS-008',
+                        severity: 'block',
+                        message: `sourceParameters.${missing.join(' ve ')} eksik. Platform null bırakır, Studio formu guard'sız okuyup sayfayı düşürür. Varsayılanları verin: sort { name:'sortField', type:'sortType', source:'query-string' }, limit { name:'limit', offset:'offset', source:'query-string' }.`,
+                        guide: 'ngapps://guides/microservice'
+                    }]
+                : [];
+        }
+    },
+    {
+        id: 'MS-010',
+        module: 'microservice',
+        appliesTo: ['create', 'update', 'preview'],
+        sourceRef: "CreateMicroserviceCommandValidator:76-86 — EnableDynamicFilters true iken Source=Table, Operation=Get, IsSingle=false ve TÜM single filtrelerin Source'u Expression olmak zorunda (PrefilterMustBeExpression). Runtime tarafı: TableMicroserviceExecutor:166 DynamicFilter.MapToFilters + Combine",
+        check: definition => {
+            if (!definition.enableDynamicFilters)
+                return [];
+            const findings = [];
+            const parameters = (definition.sourceParameters ?? {});
+            const flattenFilters = (filters) => filters
+                .filter((filter) => Boolean(filter) && typeof filter === 'object')
+                .flatMap(filter => [filter, ...flattenFilters(asArray(filter.children))]);
+            if (definition.source !== 'table' || parameters.operation !== 'get' || parameters.isSingle === true) {
+                findings.push({
+                    ruleId: 'MS-010',
+                    severity: 'block',
+                    message: "enableDynamicFilters yalnız source:'table' + operation:'get' + isSingle:false uçlarda kullanılabilir (validator reddeder).",
+                    guide: 'ngapps://guides/microservice'
+                });
+            }
+            const staticFilters = flattenFilters(asArray(parameters.filters))
+                .filter(filter => filter.filterType === 'single' && filter.source !== 'expression')
+                .map(filter => String(filter.fieldSlug ?? filter.fieldId ?? '?'));
+            if (staticFilters.length > 0) {
+                findings.push({
+                    ruleId: 'MS-010',
+                    severity: 'block',
+                    message: `enableDynamicFilters açıkken single filtrelerin hepsi source:'expression' olmalı; şu filtreler değil: ${staticFilters.join(', ')}. Platform 'PrefilterMustBeExpression' ile reddeder. Dinamik filtre uçlarında query-string filtresi YOKTUR — süzme isteği çağrıdaki 'filters' parametresiyle gelir; expression filtreleri yalnız sabit prefilter (ör. tenant/aktiflik) içindir.`,
+                    guide: 'ngapps://guides/microservice'
+                });
+            }
+            return findings;
+        }
+    },
+    {
+        id: 'MS-011',
+        module: 'microservice',
+        appliesTo: ['create', 'update', 'preview'],
+        sourceRef: "Middleware değişken akışı: ExecuteMicroserviceBehavior.HandleMiddlewaresAsync set-user/variable step'leriyle workflowContext.AddVariable; expression filtreleri aynı Jint motorundan okur (TableMicroserviceExecutor:449-515). qm kanıtı: sy-users-get-my-profile id eq user.id + Authenticate middlewareIds. middlewareIds boşken user.* runtime'da 'user is not defined' 500'ü verir",
+        check: definition => {
+            const middlewareIds = asArray(definition.middlewareIds);
+            if (middlewareIds.length > 0)
+                return [];
+            const parameters = (definition.sourceParameters ?? {});
+            const flattenFilters = (filters) => filters
+                .filter((filter) => Boolean(filter) && typeof filter === 'object')
+                .flatMap(filter => [filter, ...flattenFilters(asArray(filter.children))]);
+            const expressionEntries = [
+                ...flattenFilters(asArray(parameters.filters)),
+                ...asArray(parameters.fields).filter((field) => Boolean(field) && typeof field === 'object')
+            ].filter(entry => String(entry.source ?? '') === 'expression' && /\buser\./.test(String(entry.value ?? '')));
+            return expressionEntries.length > 0
+                ? [{
+                        ruleId: 'MS-011',
+                        severity: 'warn',
+                        message: `Expression'lar 'user.' okuyor (${expressionEntries.map(entry => String(entry.fieldSlug ?? entry.fieldId ?? '?')).join(', ')}) ama middlewareIds boş — 'user' değişkenini yalnız bir middleware'in set-user step'i kurar, bağlanmazsa runtime 'user is not defined' 500'ü döner. Auth middleware'ini definition.middlewareIds ile bağlayın (platform_guide('middleware')).`,
+                        guide: 'ngapps://guides/middleware'
+                    }]
+                : [];
+        }
+    },
+    {
+        id: 'MS-012',
+        module: 'microservice',
+        appliesTo: ['create', 'update', 'preview'],
+        sourceRef: "EnumExtensions.cs:37-62 GetValueFromDescription unknown string'de null döner, StringEnumConverter<OperatorType> null'u default(Equal)='eq' yapar — kutuphane turu H4: operator:'like' sessizce eq'e düştü, arama ucu testten geçip çalışmadı. Sözlük: EntityConstants.cs OperatorType Description'ları",
+        check: definition => {
+            const parameters = (definition.sourceParameters ?? {});
+            return unknownOperatorFindings('MS-012', 'sourceParameters.filters', asArray(parameters.filters));
+        }
+    },
+    {
+        id: 'WF-015',
+        module: 'workflow',
+        appliesTo: ['create', 'update', 'preview'],
+        sourceRef: "MS-012'nin workflow table step karşılığı — step rule.filters aynı OperatorType sözlüğünü kullanır",
+        check: (definition, context) => {
+            const body = workflowBody(definition, context.workflowKind);
+            return workflowSteps(body)
+                .filter(step => step.type === 'table')
+                .flatMap(step => unknownOperatorFindings('WF-015', `'${stepLabel(step)}' table step'i (rule.filters)`, asArray((step.rule ?? {}).filters)));
+        }
+    },
+    {
+        id: 'WF-016',
+        module: 'workflow',
+        appliesTo: ['preview'],
+        sourceRef: "PreviewWorkflowCommandHandler: jsEngine.Eval(null, request.PreviewPayload.ToString()) — alan JavaScript KAYNAK METNİdir, sonucu nesne değilse evaluatedInput.ToListDictionary() boş sözlük üretir ve preview 'input: {}' ile koşar. Destek masası koşumu B-09: hata mesajı adımı suçluyor ('Please provide the X parameter'), asıl sorun girdinin hiç bağlanmamış olması",
+        check: definition => {
+            const payload = definition.previewPayload;
+            if (payload === undefined || payload === null)
+                return [];
+            if (typeof payload !== 'string') {
+                return [{
+                        ruleId: 'WF-016',
+                        severity: 'block',
+                        message: `previewPayload bir ${Array.isArray(payload) ? 'dizi' : typeof payload} — STRING olmalı. Platform alanı jsEngine.Eval ile çalıştırır; nesne gönderilirse 'Unexpected end of input' ile 500 döner. Kanonik biçim: previewPayload: "({ email: 'a@b.c', password: '1234' })".`,
+                        guide: 'ngapps://guides/workflow'
+                    }];
+            }
+            const source = payload.trim();
+            if (source.length === 0)
+                return [];
+            if (/^JSON\.stringify\s*\(/.test(source)) {
+                return [{
+                        ruleId: 'WF-016',
+                        severity: 'block',
+                        message: `previewPayload metni "${source.slice(0, 40)}…" ile başlıyor: bu ifade değerlendirilince bir STRING üretir, nesne değil — preview sessizce input: {} ile koşar ve adımlar 'parametre eksik' hatası verir (hata mesajı adımı suçlar, asıl sorun budur). JSON.stringify çağıran taraftaki JS kodudur; gövdeye ÜRETTİĞİ metni koyun: previewPayload: "({ ... })".`,
+                        guide: 'ngapps://guides/workflow'
+                    }];
+            }
+            if (source.startsWith('{') && !source.startsWith('({')) {
+                return [{
+                        ruleId: 'WF-016',
+                        severity: 'block',
+                        message: `previewPayload "{" ile başlıyor: JavaScript bunu nesne değil BLOK olarak ayrıştırır ve preview input: {} ile koşar. Parantez içine alın: previewPayload: "(${source})".`,
+                        guide: 'ngapps://guides/workflow'
+                    }];
+            }
+            return [];
+        }
+    },
+    {
+        id: 'WF-013',
+        module: 'workflow',
+        appliesTo: ['create', 'update', 'preview'],
+        sourceRef: 'MS-008 kuralının workflow karşılığı; WorkflowTableFormSort isFlowStep dalında data.sort.sortValue okur',
+        check: (definition, context) => {
+            const body = workflowBody(definition, context.workflowKind);
+            return workflowSteps(body)
+                .filter(step => step.type === 'table')
+                .flatMap(step => {
+                const rule = (step.rule ?? {});
+                const missing = ['sort', 'limit'].filter(key => !rule[key]);
+                return missing.length > 0
+                    ? [{
+                            ruleId: 'WF-013',
+                            severity: 'block',
+                            message: `'${stepLabel(step)}' table step'inde rule.${missing.join(' ve ')} eksik — Studio'da workflow sayfası 'Cannot read properties of null (reading sortValue)' ile açılmaz.`,
+                            guide: 'ngapps://guides/workflow'
+                        }]
+                    : [];
+            });
+        }
+    },
+    {
+        id: 'ENT-006',
+        module: 'entity',
+        appliesTo: ['create', 'update'],
+        sourceRef: 'sms oturumu: kullanıcının intprimarykey/guidprimarykey referans tabloları — PK identity + properties.generationType:0 (Always) ile otomatik üretilir; dbType↔commonType eşleşmesi zorunlu',
+        check: definition => {
+            const primaryKeys = asArray(definition.fields)
+                .filter((field) => Boolean(field) && typeof field === 'object')
+                .filter(field => field.primaryKey === true);
+            const findings = [];
+            for (const key of primaryKeys) {
+                const properties = (key.properties ?? {});
+                const dbType = String(key.dbType ?? '');
+                const expected = dbType === 'UUID' ? 'guid' : ['INT2', 'INT4', 'INT8'].includes(dbType) ? 'number' : null;
+                if (key.identity !== true || properties.generationType === undefined) {
+                    findings.push({
+                        ruleId: 'ENT-006',
+                        severity: 'warn',
+                        message: `'${key.slug ?? key.name}' primary key'i otomatik üretilmiyor: identity:true + properties.generationType:0 (Always) verin, yoksa her satırda id'yi elle göndermek gerekir.`,
+                        guide: 'ngapps://guides/entity'
+                    });
+                }
+                if (expected === null) {
+                    findings.push({
+                        ruleId: 'ENT-006',
+                        severity: 'warn',
+                        message: `'${key.slug ?? key.name}' primary key'i için dbType '${dbType}' beklenmiyor — UUID (guid) ya da INT2/INT4/INT8 (number) kullanın.`,
+                        guide: 'ngapps://guides/entity'
+                    });
+                }
+                else if (key.commonType !== expected) {
+                    findings.push({
+                        ruleId: 'ENT-006',
+                        severity: 'warn',
+                        message: `'${key.slug ?? key.name}' primary key'inde dbType '${dbType}' ile commonType '${key.commonType}' uyuşmuyor — '${expected}' olmalı.`,
+                        guide: 'ngapps://guides/entity'
+                    });
+                }
+            }
+            return findings;
+        }
+    },
+    {
+        id: 'ENT-007',
+        module: 'entity',
+        appliesTo: ['create', 'update'],
+        sourceRef: 'sms oturumu: enum alanı = valueOptions dolu + isEnum true; valueOptions PG CHECK constraint üretir, mevcut veri kanonik değilse migration düşer. Multi-enum (many-to-many + valueOptions) kapsam DIŞI: platform <slug>_values entity\'sini + junction\'ı kendisi üretir, isEnum aranmaz (allm2m canlı verisi)',
+        check: definition => asArray(definition.fields)
+            .filter((field) => Boolean(field) && typeof field === 'object')
+            .flatMap(field => {
+            const options = asArray(field.valueOptions);
+            if (options.length > 0 && isJunctionField(field))
+                return [];
+            if (options.length > 0 && field.isEnum !== true) {
+                return [{
+                        ruleId: 'ENT-007',
+                        severity: 'warn',
+                        message: `'${field.slug ?? field.name}' alanında valueOptions dolu ama isEnum true değil — ikisi birlikte verilmeli.`,
+                        guide: 'ngapps://guides/entity'
+                    }];
+            }
+            if (field.isEnum === true && options.length === 0) {
+                return [{
+                        ruleId: 'ENT-007',
+                        severity: 'warn',
+                        message: `'${field.slug ?? field.name}' alanı isEnum:true ama valueOptions boş — [{ value, icon }] listesi verin.`,
+                        guide: 'ngapps://guides/entity'
+                    }];
+            }
+            const malformed = options.filter((option) => Boolean(option) && typeof option === 'object').filter(option => !option.value);
+            return malformed.length > 0
+                ? [{
+                        ruleId: 'ENT-007',
+                        severity: 'warn',
+                        message: `'${field.slug ?? field.name}' alanının valueOptions öğelerinde 'value' eksik — { value: 'Aktif', icon: '#47ad10' } biçimi bekleniyor.`,
+                        guide: 'ngapps://guides/entity'
+                    }]
+                : [];
+        })
+    },
+    {
+        id: 'ENT-008',
+        module: 'entity',
+        appliesTo: ['create'],
+        sourceRef: "klinik K-001: entity slug'ları environment şemasındaki ~73 platform tablosuyla aynı isim uzayında; çakışmada 'Migration failed … relation \"X\" already exists' döner ve entity kaydı HİÇ oluşmaz. Liste TenantContextModelSnapshot'tan üretilir (npm run generate-reserved-tables)",
+        check: definition => {
+            const slug = String(definition.slug ?? '').toLowerCase();
+            if (!slug || !reservedTenantTables.includes(slug))
+                return [];
+            return [{
+                    ruleId: 'ENT-008',
+                    severity: 'block',
+                    message: `slug '${slug}' bir platform tablosunun adı — environment şeması bu tabloyu zaten taşıyor. Migration 'relation "${slug}" already exists' ile düşer ve entity kaydı hiç oluşmaz. Eş anlamlı bir ad seçin (ör. şube/branş için 'branches' yerine 'specialties').`,
+                    guide: 'ngapps://guides/entity'
+                }];
+        }
+    },
+    {
+        id: 'MS-009',
+        module: 'microservice',
+        appliesTo: ['create', 'update', 'preview'],
+        sourceRef: 'klinik K-003 + kod: TableMicroserviceExecutor.ByCreateAsync:215 sonucu FilterByKeys([PK]) ile buduyor; write operasyonunda selectFields kaydedilirken sessizce boşaltılır, dönecek alanlar returnFields ile verilir',
+        check: definition => {
+            const parameters = definition.sourceParameters;
+            if (definition.source !== 'table' || !parameters || isReadOperation(parameters))
+                return [];
+            if (String(parameters.operation ?? '').toLowerCase() === 'delete')
+                return [];
+            return asArray(parameters.returnFields).length === 0
+                ? [{
+                        ruleId: 'MS-009',
+                        severity: 'warn',
+                        message: `sourceParameters.operation='${parameters.operation}' ama returnFields boş — yanıt yalnız primary key döner. Çağıranın göreceği alanları returnFields'a ekleyin (write operasyonunda selectFields yok sayılır).`,
+                        guide: 'ngapps://guides/microservice'
+                    }]
+                : [];
+        }
+    },
+    {
+        id: 'WF-014',
+        module: 'workflow',
+        appliesTo: ['create', 'update', 'preview'],
+        sourceRef: "klinik K-010 + UI kodu: kenar sourceHandle = branch.name (workflow.helpers.ts:90-110), condition tutamağı items[].branchId (WorkflowCondition.svelte:141). Normalizasyon adı id'ye çeker; burada kalan uyuşmazlık gerçek hatadır",
+        check: (definition, context) => {
+            const body = workflowBody(definition, context.workflowKind);
+            return workflowSteps(body)
+                .filter(step => step.type === 'condition')
+                .flatMap(step => {
+                const branchIds = new Set(asArray(step.branches)
+                    .filter((branch) => Boolean(branch) && typeof branch === 'object')
+                    .map(branch => String(branch.id ?? '')));
+                const dangling = asArray((step.rule ?? {}).items)
+                    .filter((item) => Boolean(item) && typeof item === 'object')
+                    .map(item => String(item.branchId ?? ''))
+                    .filter(branchId => branchId.length > 0 && !branchIds.has(branchId));
+                return dangling.length > 0
+                    ? [{
+                            ruleId: 'WF-014',
+                            severity: 'block',
+                            message: `'${stepLabel(step)}' condition step'inde rule.items[].branchId '${dangling.join("', '")}' hiçbir branch'in id'siyle eşleşmiyor — koşul satırı hiçbir dala bağlı değil. branches[].id değerlerini kullanın.`,
+                            guide: 'ngapps://guides/workflow'
+                        }]
+                    : [];
+            });
+        }
+    },
+    {
+        id: 'FLOW-004',
+        module: 'flow',
+        appliesTo: ['create', 'update'],
+        sourceRef: 'UI: Runtime.svelte:329 (branch.id = branch.name), start.ts:4 / setter.ts:258 engine.next("always"), flow-engine.ts:79 sessiz durma, EventActionsStart.svelte:47 (sourceBranch === "always")',
+        check: definition => flowAllSteps(definition).flatMap(step => {
+            const type = String(step.type ?? '');
+            if (flowFreeBranchTypes.has(type))
+                return [];
+            const allowed = flowBranchNames[type] ?? ['always'];
+            const wrong = flowBranches(step)
+                .map(branch => String(branch.name ?? ''))
+                .filter(name => !allowed.includes(name));
+            if (wrong.length === 0)
+                return [];
+            return [{
+                    ruleId: 'FLOW-004',
+                    severity: 'block',
+                    message: `'${flowStepLabel(step)}' (type='${type}') adımının dal adı '${wrong.join("', '")}' geçersiz — ${allowed.length > 0 ? `beklenen: '${allowed.join("' | '")}'` : 'bu adım tipi dal taşımaz'}. Dal adı etiket değil motorun anahtarıdır: runtime branch.id'yi branch.name'den üretip engine.next('always') ile arar, bulamazsa akış SESSİZCE durur; Studio da zinciri sourceBranch === 'always' ile çizdiği için panel Start kartından sonrası BOŞ görünür.`,
+                    guide: 'ngapps://guides/page'
+                }];
+        })
+    },
+    {
+        id: 'FLOW-005',
+        module: 'flow',
+        appliesTo: ['create', 'update'],
+        sourceRef: 'StepManagementSchema.ToDomain (allSteps.TryGetValue → eşleşmeyen nextStepId sessizce null); flow-engine.ts:115 start arama',
+        check: definition => ['steps', 'errorSteps'].flatMap(field => {
+            const steps = flowStepList(definition[field]);
+            if (steps.length === 0)
+                return [];
+            const stepIds = new Set(steps.map(step => String(step.stepId ?? '')));
+            const dangling = steps.flatMap(step => flowBranches(step)
+                .map(branch => String(branch.nextStepId ?? ''))
+                .filter(nextStepId => nextStepId.length > 0 && !stepIds.has(nextStepId))
+                .map(nextStepId => `${flowStepLabel(step)} → '${nextStepId}'`));
+            if (dangling.length > 0) {
+                return [{
+                        ruleId: 'FLOW-005',
+                        severity: 'block',
+                        message: `${field} içinde hedefi olmayan dal var: ${dangling.join(', ')}. branches[].nextStepId hedef adımın stepId STRING'idir; eşleşmeyeni backend sessizce null'a çevirir ve akış orada biter.`,
+                        guide: 'ngapps://guides/page'
+                    }];
+            }
+            const startStep = steps.find(step => step.type === 'start');
+            if (!startStep) {
+                return [{
+                        ruleId: 'FLOW-005',
+                        severity: 'block',
+                        message: `${field} içinde type='start' adımı yok — motor akışı start adımından başlatır (flow-engine.ts:115), start yoksa hiçbir şey çalışmaz.`,
+                        guide: 'ngapps://guides/page'
+                    }];
+            }
+            const reached = new Set();
+            const queue = [String(startStep.stepId ?? '')];
+            const stepsById = new Map(steps.map(step => [String(step.stepId ?? ''), step]));
+            while (queue.length > 0) {
+                const currentId = queue.pop();
+                if (!currentId || reached.has(currentId))
+                    continue;
+                reached.add(currentId);
+                for (const branch of flowBranches(stepsById.get(currentId) ?? {})) {
+                    if (branch.nextStepId)
+                        queue.push(String(branch.nextStepId));
+                }
+            }
+            const unreachable = steps.filter(step => !reached.has(String(step.stepId ?? '')));
+            return unreachable.length > 0
+                ? [{
+                        ruleId: 'FLOW-005',
+                        severity: 'block',
+                        message: `${field} içinde start'tan erişilemeyen adım var: ${unreachable.map(flowStepLabel).join(', ')}. Önceki adımın branches[].nextStepId alanına bu adımların stepId'sini yazın.`,
+                        guide: 'ngapps://guides/page'
+                    }]
+                : [];
+        })
+    },
+    {
+        id: 'FLOW-006',
+        module: 'flow',
+        appliesTo: ['create', 'update'],
+        sourceRef: 'setter.ts:68 process() yalnız change|fill dallanır; setter.types.ts SetterArgumentIterateeType. Backend StepManagementIterate.Type serbest string olduğu için geçersiz değer 200 döner',
+        check: definition => flowAllSteps(definition)
+            .filter(step => step.type === 'setter')
+            .flatMap(step => flowIteratees(step)
+            .map(iteratee => String(iteratee.type ?? ''))
+            .filter(type => !flowSetterIterateeTypes.has(type))
+            .map(type => ({
+            ruleId: 'FLOW-006',
+            severity: 'block',
+            message: `'${flowStepLabel(step)}' setter adımında iteratees[].type='${type}' geçersiz — yalnız 'change' (tek prop'a değer yaz) ve 'fill' (diziyi mapping ile eşleyerek yaz) vardır. Backend serbest string sakladığı için istek 200 döner ama setter.ts hiçbir dala girmez: adım çalışır, HİÇBİR ŞEY yapmaz.`,
+            guide: 'ngapps://guides/page'
+        })))
+    },
+    {
+        id: 'WF-018',
+        module: 'workflow',
+        appliesTo: ['create', 'update', 'preview'],
+        sourceRef: "LoopStep.cs:41 çocuk kuralı rule.Children.FirstOrDefault() ile okur ama API sözleşmesinde alan TEKİLdir (StepRuleDto.StepRule, WorkflowDto.cs:498). 'children' gönderilirse Children boş kalır, çocuk adım null rule ile koşar ve loop NullReferenceException verir — hata arrayExpression'ı işaret ettiği için yanlış yere baktırır. Ölçüm: anket-admin/anket-kaydet, 2026-08-19",
+        check: (definition, context) => {
+            const body = workflowBody(definition, context.workflowKind);
+            return workflowSteps(body)
+                .filter(step => step.type === 'loop')
+                .flatMap((step) => {
+                const rule = (step.rule ?? {});
+                const findings = [];
+                if (!rule.stepRule) {
+                    const hasChildren = Array.isArray(rule.children) && rule.children.length > 0;
+                    findings.push({
+                        ruleId: 'WF-018',
+                        severity: 'block',
+                        message: `'${stepLabel(step)}' loop step'inde rule.stepRule yok${hasChildren ? " — ama rule.children dolu: çocuk kural alanının adı 'children' DEĞİL 'stepRule'dur (tekil)" : ''}. Çocuksuz loop çalışma anında NullReferenceException verir ve hata mesajı arrayExpression'ı suçlar. Çocuğun kendi rule gövdesini rule.stepRule'a koyun; geçerli öğeye çocuk ifadelerinde 'loopItem' ile erişilir, loop'un çıktısı [{ item, result }] dizisidir.`,
+                        guide: 'ngapps://guides/workflow'
+                    });
+                }
+                if (String(rule.arrayExpression ?? '').trim().length === 0) {
+                    findings.push({
+                        ruleId: 'WF-018',
+                        severity: 'block',
+                        message: `'${stepLabel(step)}' loop step'inde rule.arrayExpression boş — döngü neyi yineleyeceğini bilemez. Diziyi üreten JS ifadesini yazın (ör. "input.questions || []").`,
+                        guide: 'ngapps://guides/workflow'
+                    });
+                }
+                return findings;
+            });
+        }
+    },
+    {
+        id: 'FLOW-017',
+        module: 'flow',
+        appliesTo: ['create', 'update'],
+        sourceRef: "setter.ts:116 change() ve fill() her dalda machine.setNode(element, { [property]: … }) çağırır; element/property boşsa çağrı sessizce hiçbir düğüme yazmaz. Ölçüm: anket-spike/spike-public 'Anketi yukle' + 'Cevabi gonder' akışları, 2026-08-19. Platform bu alanları DOĞRULAMAZ (bilinçli ürün kararı: doğrulama platform çekirdeğine değil tool katmanına ait); tek savunma bu kuraldır",
+        check: definition => flowAllSteps(definition)
+            .filter(step => step.type === 'setter')
+            .flatMap(step => flowIteratees(step).flatMap((iteratee) => {
+            const missing = ['element', 'property'].filter(field => String(iteratee[field] ?? '').trim().length === 0);
+            if (missing.length === 0)
+                return [];
+            return [{
+                    ruleId: 'FLOW-017',
+                    severity: 'block',
+                    message: `'${flowStepLabel(step)}' setter adımının iteratees girdisinde ${missing.join(' ve ')} yok. setter.ts her dalda machine.setNode(element, { [property]: value }) çağırır — ikisinden biri boşken adım ÇALIŞIR, hata vermez ve HİÇBİR ŞEY yazmaz. element = hedef komponentin elementId'si (page_schema_get ile doğrulayın), property = yazılacak prop adı (html komponentine veri basmak için 'context', tabloya satır basmak için 'rows'). Platform bu gövdeyi 200 ile kabul eder — tek savunma budur.`,
+                    guide: 'ngapps://guides/page'
+                }];
+        }))
+    },
+    {
+        id: 'FLOW-007',
+        module: 'flow',
+        appliesTo: ['create', 'update'],
+        sourceRef: "setter.ts:161 Storage dalı iteratee.mapping.source'u guard'sız okur; mapping null ise TypeError try/catch'e düşer ve adım hata verir",
+        check: definition => flowAllSteps(definition)
+            .filter(step => step.type === 'setter')
+            .flatMap(step => flowIteratees(step)
+            .filter(iteratee => flowValueOf(iteratee).type === 'storage' && !iteratee.mapping)
+            .map(() => ({
+            ruleId: 'FLOW-007',
+            severity: 'block',
+            message: `'${flowStepLabel(step)}' setter adımında value.type='storage' ama mapping yok. setter.ts mapping.source'u guard'sız okur → TypeError. En az mapping: { "source": "", "mappings": {} } verin.`,
+            guide: 'ngapps://guides/page'
+        })))
+    },
+    {
+        id: 'FLOW-008',
+        module: 'flow',
+        appliesTo: ['create', 'update'],
+        sourceRef: 'microservice.ts:89 machine.setStorage(task.name, …) — storage anahtarı adımın ADI. setter.ts:161 mapping.source doluysa anahtar odur. flow-execution.functions.ts: code sandbox\'ında sonuçlar Steps["<ad>"] ile okunur, stepId diye bir değişken yoktur',
+        check: definition => {
+            const steps = flowAllSteps(definition);
+            const names = new Set(steps.map(step => String(step.name ?? '')).filter(name => name.length > 0));
+            const stepIds = new Set(steps.map(step => String(step.stepId ?? '')).filter(stepId => stepId.length > 0));
+            return steps
+                .filter(step => step.type === 'setter')
+                .flatMap(step => flowIteratees(step).flatMap((iteratee) => {
+                const value = flowValueOf(iteratee);
+                const isBareIdentifier = typeof value.ref === 'string' && /^[A-Za-z_$][\w$]*$/.test(value.ref);
+                const isStorage = value.type === 'storage';
+                if (!isStorage && !(value.type === 'code' && isBareIdentifier))
+                    return [];
+                const { reference, origin } = isStorage
+                    ? flowStorageReference(iteratee)
+                    : { reference: String(value.ref), origin: 'value.ref' };
+                const root = flowStorageRoot(reference);
+                if (root.length === 0 || names.has(root))
+                    return [];
+                if (stepIds.has(root)) {
+                    const stepName = steps.find(candidate => String(candidate.stepId ?? '') === root)?.name ?? '<adım adı>';
+                    const fix = origin === 'mapping.source'
+                        ? `mapping.source: "${stepName}.data"`
+                        : `{ "type": "storage", "ref": "${stepName}.data" }`;
+                    return [{
+                            ruleId: 'FLOW-008',
+                            severity: 'block',
+                            message: `'${flowStepLabel(step)}' setter adımı ${origin}='${reference}' ile bir stepId'ye bakıyor; storage anahtarı adımın ADIdır. Doğrusu: ${fix}. value.type='code' ise ifade JS olarak koşar ve '${reference}' tanımsız değişken hatası verir — kod içinden okuma biçimi Steps["<adım adı>"].data'dır.`,
+                            guide: 'ngapps://guides/page'
+                        }];
+                }
+                return isStorage
+                    ? [{
+                            ruleId: 'FLOW-008',
+                            severity: 'warn',
+                            message: `'${flowStepLabel(step)}' setter adımı ${origin}='${reference}' ile storage '${root}' okuyor ama bu akışta bu adı taşıyan adım yok — anahtarı yazan adım başka bir akıştaysa yok sayın, değilse ref adım adına eşitlenmeli.`,
+                            guide: 'ngapps://guides/page'
+                        }]
+                    : [];
+            }));
+        }
+    },
+    {
+        id: 'FLOW-009',
+        module: 'flow',
+        appliesTo: ['create', 'update'],
+        sourceRef: 'microservice.ts:81-90 — isRaw false ise storage { data, headers, error } sarmalı, değilse ham response.data',
+        check: definition => {
+            const steps = flowAllSteps(definition);
+            const microserviceStepsByName = new Map(steps
+                .filter(step => step.type === 'microservice' && step.name)
+                .map(step => [String(step.name), step]));
+            return steps
+                .filter(step => step.type === 'setter')
+                .flatMap(step => flowIteratees(step).flatMap(iteratee => {
+                const value = flowValueOf(iteratee);
+                if (value.type !== 'storage')
+                    return [];
+                const { reference, origin } = flowStorageReference(iteratee);
+                if (reference.length === 0)
+                    return [];
+                const segments = reference.split('.');
+                const root = flowStorageRoot(reference);
+                const source = microserviceStepsByName.get(root);
+                if (!source)
+                    return [];
+                const isRaw = (source.args ?? {}).isRaw === true;
+                const readsWrapper = segments.includes('data');
+                if (!isRaw && !readsWrapper) {
+                    return [{
+                            ruleId: 'FLOW-009',
+                            severity: 'block',
+                            message: `'${flowStepLabel(step)}' setter adımı ${origin}='${reference}' okuyor ama '${root}' adımı isRaw=false ile çalışıyor → storage { data, headers, error } sarmalıdır. Ref '${root}.data' olmalı; aksi hâlde prop'a dizinin yerine sarmal nesne yazılır.`,
+                            guide: 'ngapps://guides/page'
+                        }];
+                }
+                return isRaw && readsWrapper
+                    ? [{
+                            ruleId: 'FLOW-009',
+                            severity: 'block',
+                            message: `'${flowStepLabel(step)}' setter adımı ${origin}='${reference}' okuyor ama '${root}' adımı isRaw=true — storage ham cevaptır, '.data' diye bir alan yoktur. Ref '${root}' olmalı.`,
+                            guide: 'ngapps://guides/page'
+                        }]
+                    : [];
+            }));
+        }
+    },
+    {
+        id: 'FLOW-010',
+        module: 'flow',
+        appliesTo: ['create', 'update'],
+        sourceRef: 'flow-machine.ts:228 getStorage → dot-prop getProperty (nokta yol ayırıcısıdır); event-actions.mappers.ts:142 Studio her okumada microservice adımının isRaw\'ını false\'a çeker',
+        check: definition => flowAllSteps(definition)
+            .filter(step => step.type === 'microservice')
+            .flatMap(step => {
+            const findings = [];
+            if (String(step.name ?? '').includes('.')) {
+                findings.push({
+                    ruleId: 'FLOW-010',
+                    severity: 'warn',
+                    message: `'${flowStepLabel(step)}' adımının adında nokta var. Storage okuması dot-prop ile yapılır; noktalı ad yol segmentine bölünür ve setter ref'i asla çözülmez.`,
+                    guide: 'ngapps://guides/page'
+                });
+            }
+            if ((step.args ?? {}).isRaw === true) {
+                findings.push({
+                    ruleId: 'FLOW-010',
+                    severity: 'warn',
+                    message: `'${flowStepLabel(step)}' adımı isRaw=true. Studio bu akışı her AÇTIĞINDA isRaw'ı false'a çevirir (event-actions.mappers.ts) ve storage ref'lerine '.data' ekler; kullanıcı akışı bir kez kaydederse ref'leriniz değişir. Kalıcı olması için isRaw'ı verme ve ref'i '<adım adı>.data' yaz.`,
+                    guide: 'ngapps://guides/page'
+                });
+            }
+            return findings;
+        })
+    },
+    {
+        id: 'FLOW-011',
+        module: 'flow',
+        appliesTo: ['create', 'update'],
+        sourceRef: 'microservice.ts:79-90 başarı yolunda storage { data, headers, error }; microservice.ts:132-135 HATA yolunda { error, data } — headers YOK. runCode TypeError\'ı yutar (flow-execution.functions.ts:403-408) ve flow-engine.ts:53 bir sonraki next() çağrısında akışı onError\'a düşürür',
+        check: definition => {
+            const steps = flowAllSteps(definition);
+            const microserviceStepsByName = new Map(steps
+                .filter(step => step.type === 'microservice' && step.name)
+                .map(step => [String(step.name), step]));
+            return steps.flatMap(step => flowCodeExpressions(step).flatMap(({ expression, origin }) => {
+                flowHeadersAccess.lastIndex = 0;
+                const findings = [];
+                let match;
+                while ((match = flowHeadersAccess.exec(expression)) !== null) {
+                    const name = match[1] ?? match[2] ?? '';
+                    const source = microserviceStepsByName.get(name);
+                    if (source && (source.args ?? {}).isRaw === true) {
+                        findings.push({
+                            ruleId: 'FLOW-011',
+                            severity: 'block',
+                            message: `'${flowStepLabel(step)}' adımının ${origin} ifadesi Steps.${name}.headers okuyor ama '${name}' adımı isRaw=true ile çalışıyor — o zaman storage ham response.data'dır, 'headers' diye bir alan HİÇ yazılmaz (microservice.ts:88). İfade her koşuda TypeError verir. isRaw'ı kaldırın (normalize false'a çeker) ya da header okumaktan vazgeçin.`,
+                            guide: 'ngapps://guides/page'
+                        });
+                        continue;
+                    }
+                    findings.push({
+                        ruleId: 'FLOW-011',
+                        severity: 'warn',
+                        message: `'${flowStepLabel(step)}' adımının ${origin} ifadesinde Steps.${name}.headers guard'sız okunuyor. İstek HATA aldığında storage { error, data } olarak yazılır ve 'headers' alanı yoktur (microservice.ts:132) → TypeError; runCode undefined döner (prop'a NaN yazılır), ifade hatası toast'ı düşer ve flow-engine.ts:53 akışı onError'a çevirip durdurabilir. Guard'lı yazın: Number(Steps.${name}?.headers?.["total-count"] ?? 0).`,
+                        guide: 'ngapps://guides/page'
+                    });
+                }
+                return findings;
+            }));
+        }
+    },
+    {
+        id: 'FLOW-012',
+        module: 'flow',
+        appliesTo: ['create', 'update'],
+        sourceRef: 'setter.ts:83-104 map() iterator: object[key] = … — mapping anahtarı DÜZ yazılır, iç içe nesne üretilmez (okuma tarafı dot-prop ile çözer)',
+        check: definition => flowAllSteps(definition)
+            .filter(step => step.type === 'setter')
+            .flatMap(step => flowIteratees(step).flatMap(iteratee => {
+            const dotted = Object.keys(flowMappingsOf(iteratee)).filter(key => key.includes('.'));
+            return dotted.length > 0
+                ? [{
+                        ruleId: 'FLOW-012',
+                        severity: 'warn',
+                        message: `'${flowStepLabel(step)}' setter adımının mapping anahtarında nokta var: '${dotted.join("', '")}'. Mapper anahtarı DÜZ yazar (object['${dotted[0]}']), iç içe alan üretmez; kolon bunu nokta yolu olarak çözmeye çalışırsa değeri göremez. Kolonun kendi key'ini düz anahtar olarak verin (örn. 'parent_name'), kaynak yolunu ise ref'e yazın ({ "type": "item", "ref": "parent_title.name" }).`,
+                        guide: 'ngapps://guides/page'
+                    }]
+                : [];
+        }))
+    },
+    {
+        id: 'FLOW-014',
+        module: 'flow',
+        appliesTo: ['create', 'update'],
+        sourceRef: "flow-trigger.ts: task.argument.flowId varsa engine.run(flowId), yoksa triggerElementId + triggerElementEvent ile hedef komponentin olay akışı çalıştırılır; ikisi de yoksa adım hiçbir şey yapmadan engine.next('always') der. Backend StepManagementArgument.ToDomain aynı ikiliği bekler (destek masası koşumu B-02)",
+        check: definition => flowAllSteps(definition)
+            .filter(step => step.type === 'flow-trigger')
+            .flatMap((step) => {
+            const args = (step.args ?? {});
+            const hasFlowId = typeof args.flowId === 'string' && args.flowId.length > 0;
+            const hasElement = typeof args.triggerElementId === 'string' && args.triggerElementId.length > 0;
+            if (hasFlowId && hasElement) {
+                return [{
+                        ruleId: 'FLOW-014',
+                        severity: 'warn',
+                        message: `'${flowStepLabel(step)}' flow-trigger adımında hem args.flowId hem args.triggerElementId var; runtime önce flowId'ye bakar (flow-trigger.ts) ve element dalına HİÇ girmez. Birini silin.`,
+                        guide: 'ngapps://guides/page'
+                    }];
+            }
+            if (hasFlowId)
+                return [];
+            if (hasElement) {
+                return typeof args.triggerElementEvent === 'string' && args.triggerElementEvent.length > 0
+                    ? []
+                    : [{
+                            ruleId: 'FLOW-014',
+                            severity: 'block',
+                            message: `'${flowStepLabel(step)}' flow-trigger adımında args.triggerElementId var ama args.triggerElementEvent yok — runtime hedef komponentin olay listesinde eşleşme arar, olay adı olmadan hiçbir akış çalışmaz. Olay adını component_get'ten alın.`,
+                            guide: 'ngapps://guides/page'
+                        }];
+            }
+            return [{
+                    ruleId: 'FLOW-014',
+                    severity: 'block',
+                    message: `'${flowStepLabel(step)}' flow-trigger adımının args'ı boş. İki geçerli şekil var: (1) başka bir akışı çalıştır → args: { "flowId": "<hedef flow id>" }; (2) bir komponentin olay akışını çalıştır → args: { "triggerElementId": "<elementId>", "triggerElementEvent": "<component_get events listesinden ad>" }. İkisi de yoksa backend 404 'Kayıt bulunamadı' döner (StepManagementArgument.ToDomain trigger dalı), dönmese bile adım hiçbir şey yapmaz.`,
+                    guide: 'ngapps://guides/page'
+                }];
+        })
+    },
+    {
+        id: 'FLOW-015',
+        module: 'flow',
+        appliesTo: ['create', 'update'],
+        sourceRef: "microservice.ts: adım args.microserviceId ile ucu çözer; boşsa istek /m/<app>/null adresine gider ve 404 döner. Kayıt 200 kabul edilir, hata yalnız O DAL koşunca ortaya çıkar (klinik panel/randevular koşumu 2026-08-18)",
+        check: definition => flowAllSteps(definition)
+            .filter(step => step.type === 'microservice')
+            .flatMap((step) => {
+            const args = (step.args ?? {});
+            const microserviceId = args.microserviceId;
+            return typeof microserviceId === 'string' && microserviceId.length > 0
+                ? []
+                : [{
+                        ruleId: 'FLOW-015',
+                        severity: 'block',
+                        message: `'${flowStepLabel(step)}' microservice adımının args.microserviceId'si boş. Kayıt 200 döner ama çalışma anında istek '/m/<application>/null' adresine gidip 404 alır ve sonraki adım hata gövdesini veri sanır. Ucu microservice_list'ten seçip args: { "microserviceId": "<id>", "isRaw": false, "parameters": [] } verin; ucu henüz yaratmadıysanız önce onu yaratın, adımı boş bırakıp "sonra bağlarım" demeyin.`,
+                        guide: 'ngapps://guides/page'
+                    }];
+        })
+    },
+    {
+        id: 'FLOW-016',
+        module: 'flow',
+        appliesTo: ['create', 'update'],
+        sourceRef: "Page.user middleware'in set-user çıktısıdır ve sayfa middlewareIds ile bağlı değilse UNDEFINED'dır; ayrıca set-user DTO'su çoğu kurulumda roles dizisini taşımaz (yalnız role / roles_csv). klinik+kutuphane+obs koşumu 2026-08-18",
+        check: definition => flowAllSteps(definition).flatMap((step) => {
+            const source = JSON.stringify(step.args ?? {});
+            if (!source.includes('Page.user'))
+                return [];
+            const findings = [];
+            const unguarded = readsBeforeGuard(source, 'Page.user');
+            if (unguarded) {
+                findings.push({
+                    ruleId: 'FLOW-016',
+                    severity: 'warn',
+                    message: `'${flowStepLabel(step)}' adımı 'Page.user' alanını guard'sız okuyor. Page.user middleware'in set-user çıktısıdır ve SAYFA o middleware'e (page_update middlewareIds) bağlı değilse undefined'dır — 'Cannot read properties of undefined' ile ifade patlar, condition adımında bu sessizce else dalına düşmek demektir. Köke bir kez guard'lı dokunun — 'var u = Page.user || {};', 'Page.user && Page.user.x', 'Page.user?.x', 'typeof Page.user' biçimlerinin hepsi kabul edilir — ve sayfanın middlewareIds'ini verin.`,
+                    guide: 'ngapps://guides/expressions'
+                });
+            }
+            if (/Page\.user\s*\.\s*roles(?![A-Za-z0-9_])/.test(source)) {
+                findings.push({
+                    ruleId: 'FLOW-016',
+                    severity: 'warn',
+                    message: `'${flowStepLabel(step)}' adımı 'Page.user.roles' DİZİSİNİ okuyor. set-user DTO'su diziyi çoğu kurulumda düşürür (dto_get ile bakın: genelde yalnız 'role', 'role_name', 'roles_csv' vardır) — dizi undefined gelir, '|| []' yüzünden hata da vermez ve rol dalları sessizce hiç eşleşmez. CSV'yi kullanın: var rc = u.roles_csv || (u.role ? ',' + u.role + ',' : ''); rc.indexOf(',admin,') >= 0.`,
+                    guide: 'ngapps://guides/expressions'
+                });
+            }
+            return findings;
+        })
+    },
+    {
+        id: 'MS-013',
+        module: 'microservice',
+        appliesTo: ['create', 'update', 'preview'],
+        sourceRef: "PostgreSqlRelationHandler.HandleJoin: ProcessJoinTree(entity, alias, joins) kök alias'ı doğrudan SqlKata'ya ON kolonunun SOL tarafı olarak verir ($\"{currentAlias}.{relationField.Slug}\"). Alias boşsa SQL'e '.<alan>' gider, SqlKata onu \"\".\"<alan>\" diye tırnaklar, Postgres 42601 zero-length delimited identifier döner. Runtime'da varsayılan atanmaz — Microservice.cs:671 yalnız şema üretiminde Entity.Slug'a düşer (crm koşumu B-2)",
+        check: definition => {
+            const parameters = (definition.sourceParameters ?? {});
+            if (definition.source !== 'table')
+                return [];
+            if (asArray(parameters.joins).length === 0)
+                return [];
+            if (String(parameters.alias ?? '').trim() !== '')
+                return [];
+            return [{
+                    ruleId: 'MS-013',
+                    severity: 'block',
+                    message: "sourceParameters.alias (KÖK tablo alias'ı) boş ama join var: join'in ON koşulu '<kökAlias>.<ilişkiAlanı>' olarak kurulduğu için alias'sız gövde Postgres'te opak '42601: zero-length delimited identifier' hatası verir — ne kayıt ne çalıştırma sebebi söyler. alias'ı kök entity'nin slug'ıyla doldurun (kök selectFields'ta kullandığınız alias ile aynı olmalı).",
+                    guide: 'ngapps://guides/microservice'
+                }];
+        }
+    },
+    {
+        id: 'WF-019',
+        module: 'workflow',
+        appliesTo: ['create', 'update', 'preview'],
+        sourceRef: "MS-013'ün table step karşılığı: TableStep.ByGetAsync → HandleJoin(entityDto, schema.SourceEntity.Alias, …). Gateway alias'ı gövdeden türetmeye çalışır (normalizeTableParameters); türetilemediğinde bu kural konuşur",
+        check: (definition, context) => {
+            const body = workflowBody(definition, context.workflowKind);
+            return workflowSteps(body)
+                .filter(step => step.type === 'table')
+                .flatMap((step) => {
+                const rule = (step.rule ?? {});
+                if (asArray(rule.joins).length === 0)
+                    return [];
+                if (String(rule.alias ?? '').trim() !== '')
+                    return [];
+                return [{
+                        ruleId: 'WF-019',
+                        severity: 'block',
+                        message: `'${stepLabel(step)}' table step'inde join var ama rule.alias (KÖK tablo alias'ı) boş: join'in ON koşulu '<kökAlias>.<ilişkiAlanı>' olarak kurulur, boş alias SQL'e '.<alan>' yazar ve Postgres 42601 (zero-length delimited identifier) döner — adım hiç çalışmaz, hata da sebebi söylemez. rule.alias'ı kök entity'nin slug'ıyla (kök selectFields'taki alias) doldurun.`,
+                        guide: 'ngapps://guides/workflow'
+                    }];
+            });
+        }
+    },
+    {
+        id: 'WF-020',
+        module: 'workflow',
+        appliesTo: ['create', 'update', 'preview'],
+        sourceRef: "row_list ilişki alanını HER ZAMAN nesne döndürür (GetRowsQuery.ProcessRelation her ilişki alanı için join üretir), table step/microservice ise YALNIZ joins'te bildirdiğin ilişkiyi nesneye çevirir (PostgreSqlRelationHandler.ModifyResponse → ProcessJoins). Join'siz okunan ilişki alanı DÜZ FK string'idir; '<alan>.<altAlan>' okuması undefined verir ve sessizce boş role/boş liste üretir (crm koşumu B-1)",
+        check: (definition, context) => {
+            const body = workflowBody(definition, context.workflowKind);
+            return workflowSteps(body).flatMap((step) => {
+                const source = JSON.stringify(step.rule ?? {});
+                const reads = [...source.matchAll(/\.([A-Za-z_][A-Za-z0-9_]*_id)\s*\.\s*[A-Za-z_]/g)].map(match => match[1]);
+                if (reads.length === 0)
+                    return [];
+                if (/_id\s*(&&|\?|\|\|)/.test(source))
+                    return [];
+                return [{
+                        ruleId: 'WF-020',
+                        severity: 'warn',
+                        message: `'${stepLabel(step)}' adımı bir ilişki alanının İÇİNİ okuyor (${[...new Set(reads)].join(', ')}). Table adımı ilişki alanını yalnız o ilişki için 'joins' bildirdiyseniz { id, <displayAlanı> } nesnesi döndürür; join'siz okumada DÜZ FK string'i gelir ve '.<altAlan>' UNDEFINED olur — hata vermez, sessizce boş sonuç üretir (rol dizisi boşalır, yetki kapısı yanlış karar verir). İki çözüm: (1) adıma o ilişki için join + selectFields ekleyin, (2) hedef tabloyu ayrı bir table adımıyla okuyup id üzerinden eşleştirin. Her iki şekle dayanan yazım: 'var v = x.${reads[0]} && x.${reads[0]}.id ? x.${reads[0]}.id : x.${reads[0]};'`,
+                        guide: 'ngapps://guides/workflow'
+                    }];
+            });
+        }
+    },
+    {
+        id: 'MW-003',
+        module: 'workflow',
+        appliesTo: ['create', 'update', 'preview'],
+        sourceRef: "set-user değişkeni istek kapsamındaki WorkflowContext'e yazılır (SetUserStep → AddVariable('user')) ve sonraki middleware'in motoru onu görür (WorkflowRunner her koşuda JavascriptEngineInstance'ı _variables'tan kurar; sıra ExecuteMicroserviceBehavior:96 / ExecutePageBehavior:121 → OrderBy(m => m.Name)). Ama kuran middleware set-user'a ULAŞMADAN biterse (çerez yok, koşul dalı) değişken hiç doğmaz ve okuyan middleware ham 'user is not defined' ile 500 verir — 401 değil (crm koşumu B-3)",
+        check: (definition, context) => {
+            if (context.workflowKind !== 'middleware')
+                return [];
+            const steps = workflowSteps(definition);
+            if (steps.some(step => step.type === 'set-user'))
+                return [];
+            const readers = steps.filter(step => /\buser\s*[.\]]/.test(JSON.stringify(step.rule ?? {})));
+            return readers.length === 0
+                ? []
+                : [{
+                        ruleId: 'MW-003',
+                        severity: 'warn',
+                        message: `Bu middleware 'user' okuyor (${readers.map(stepLabel).join(', ')}) ama kendisi bir set-user adımı taşımıyor: değişken BAŞKA bir middleware'in set-user'ından gelmek zorunda. Sıra ada göredir (alfabetik) ve değişken istek boyunca yaşar, ama kuran middleware set-user'a ulaşmadan biterse (token/çerez yok, koşul else dalı) 'user' hiç tanımlanmaz ve bu adım ham 'user is not defined' ile 500 döner — kullanıcı 401 yerine 500 görür. Doğrusu: rol/yetki kapısını kimlik middleware'inin İÇİNE, set-user'dan sonra koyun (platform_guide('middleware') Tarif 3b). Zinciri korumak istiyorsanız ifadeyi guard'layın: 'typeof user === \'undefined\' ? false : Authorized(user.roles)'.`,
+                        guide: 'ngapps://guides/middleware'
+                    }];
+        }
+    }
+];