@appaflytech/zeyrek-ai-mcp 0.0.36 → 0.0.40

package/dist/knowledge/access.js

@@ -0,0 +1,802 @@
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { applyPolicyMode } from './policy.js';
+/**
+ * Platformun kendisinin yönettiği hazır entity'ler (`Defaults.SystemManagedEntityIds`,
+ * EntityConstants.cs). Genel satır yazma yolu (`entities/{id}/row*`, table kaynaklı uç, table
+ * step) bunlara `400 SystemEntityWriteNotAllowed` döner: organizasyon ağacı senkron saga'sıyla ve
+ * Studio'nun `organization/*` uçlarıyla, policy kataloğu `access/*` uçlarıyla yazılır. Id'ler
+ * her kurulumda aynı sabitlerdir; slug'lar entity kaydının adıdır.
+ */
+export const organizationStructureEntities = {
+    organization_units: '01a0a05e-1c9a-7022-a0c7-6b8320756a4c',
+    organization_unit_closure: '01a0a05e-1ca3-7b6a-9f1b-7f1633f7f05a',
+    organization_positions: '01a0a05e-1ca3-700f-95c6-18fe1e30079c',
+    organization_position_closure: '01a0a05e-1ca4-7b73-b90e-4aa7d8eeeeef',
+    user_positions: '01a0a05e-1ca4-7841-b6b3-45c5892d5501'
+};
+export const accessCatalogEntities = {
+    access_permissions: '01a0a05e-1ca5-73f1-ace1-2550ecc3713a',
+    access_resources: '01a0a05e-1ca5-7b96-a910-47c2132c31cf',
+    access_policies: '01a0a05e-1ca5-7d16-9448-01ecff8cd827',
+    access_grants: '01a0a05e-1ca5-77c9-ba35-273920b57527',
+    access_assignments: '01a0a05e-1ca6-75a7-9479-3c522be60ef9'
+};
+/**
+ * Yerleşik datasource'un ağaçtaki öneki: `DatasourceTreeDto.Slug` datasource'un ADIDIR ve seed onu
+ * "Built-in Datasource" diye açar (id her kurulumda `DatasourceDefaults.BuiltInDatasourceId`). Önek
+ * harf ve rakam dışındaki karakterleri atılarak karşılaştırılır: 'BuiltIn', 'built-in', 'Built-in Datasource'.
+ */
+const builtInDatasourcePrefixes = new Set(['builtin', 'builtindatasource']);
+/**
+ * `entityId` üç biçimde gelir: GUID, slug ya da `datasource/slug`. Backend yalnız entity id'sine bakar
+ * (`SystemManagedEntityIds.Contains(entityDto.Id)`): dış datasource'taki aynı adlı tablo
+ * (`ik/user_positions`) serbesttir. Bu yüzden GUID her zaman, slug yalnız öneksizse ya da önek yerleşik
+ * datasource'sa eşleşir; başka adla yazılmış önek çözümden sonra id'yle denetlenir (`rows.ts`). Eşleşme
+ * istek gitmeden yapılır ve büyük/küçük harf duyarsızdır.
+ */
+export function systemManagedEntity(ref) {
+    if (typeof ref !== 'string' || ref.trim() === '')
+        return undefined;
+    const value = ref.trim().toLowerCase();
+    const separator = value.indexOf('/');
+    const slug = separator === -1 ? value : value.slice(separator + 1);
+    const slugApplies = separator === -1 || builtInDatasourcePrefixes.has(value.slice(0, separator).replace(/[^a-z0-9]/g, ''));
+    for (const [group, entities] of [['organization', organizationStructureEntities], ['access', accessCatalogEntities]]) {
+        for (const [entitySlug, id] of Object.entries(entities)) {
+            if (id === value || (slugApplies && entitySlug === slug))
+                return { slug: entitySlug, group };
+        }
+    }
+    return undefined;
+}
+/**
+ * İzin kataloğu (`AccessPermissionConstants`, b-22 — 43 slug; BPM b-01 beşini ekledi, 2026-09-24'te
+ * `automation.trigger` çıktı: otomasyon yetki kataloğunda değil — K-2). `supportsScope` altı entity
+ * eyleminde ve `process.view-all`'da, `supportsFieldAccess` yalnız `field.read`'te. Katalog yalnız kompleks projede
+ * tohumlanır; kaynağı `access_permission_list`'tir, bu kopya istek gitmeden denetim içindir.
+ */
+export const accessPermissionSlugs = [
+    'entity.read', 'entity.create', 'entity.update', 'entity.delete', 'entity.export', 'entity.import', 'entity.reveal', 'entity.reassign', 'entity.audit',
+    'field.read', 'field.write', 'field.filter',
+    'row.read', 'row.update', 'row.delete', 'row.export', 'row.reveal',
+    'microservice.execute', 'page.view', 'workflow.execute', 'ui-flow.run', 'function.execute', 'microfunction.execute',
+    'query.execute', 'query.unrestricted', 'view.read',
+    'file.read', 'file.upload', 'file.delete', 'folder.read', 'folder.upload', 'folder.delete',
+    'organization-unit.read', 'organization-unit.manage', 'organization-unit.assign',
+    'system.access.manage', 'system.access.explain', 'system.user.read', 'system.user.manage',
+    'process.start', 'process.manage', 'process.view-all', 'task.complete', 'task.reassign'
+];
+export const scopedPermissions = new Set(['entity.read', 'entity.update', 'entity.delete', 'entity.export', 'entity.reveal', 'entity.reassign', 'process.view-all']);
+export const accessResourceTypes = ['entity', 'field', 'row', 'microservice', 'page', 'workflow', 'automation', 'ui-flow', 'function', 'microfunction', 'query', 'view', 'file', 'folder', 'organization-unit', 'system', 'process', 'task'];
+export const accessScopes = ['own', 'unit', 'unit-tree', 'subordinates', 'function', 'company', 'all'];
+const knownPermissions = new Set(accessPermissionSlugs);
+const conditionSubjects = new Set(['userId', 'unitIds', 'positionIds', 'companyIds', 'roleSlugs', 'functionCodes']);
+const equalityOperators = new Set(['eq', 'neq']);
+const membershipOperators = new Set(['in', 'notin']);
+const comparisonOperators = new Set(['lt', 'lte', 'gt', 'gte']);
+const nullnessOperators = new Set(['isnull', 'isnotnull']);
+const maxConditionDepth = 5;
+const maxConditionNodes = 50;
+function asObject(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+}
+function asList(value) {
+    return Array.isArray(value) ? value : [];
+}
+function hasValue(value) {
+    return value !== undefined && value !== null && value !== '';
+}
+/** `ConditionNodeValidator` aynası (b-26): derinlik ≤ 5, düğüm ≤ 50, işleç ↔ değer uyumu. */
+function conditionProblems(node, path, depth, counter, into) {
+    const record = asObject(node);
+    if (!record) {
+        into.push(`${path}: boş ya da nesne değil`);
+        return;
+    }
+    if (depth > maxConditionDepth) {
+        into.push(`${path}: derinlik ${maxConditionDepth}'i aşıyor`);
+        return;
+    }
+    if (++counter.nodes > maxConditionNodes) {
+        into.push(`${path}: düğüm sayısı ${maxConditionNodes}'yi aşıyor`);
+        return;
+    }
+    const isGroup = record.all !== undefined || record.any !== undefined;
+    if (record.all !== undefined && record.any !== undefined)
+        into.push(`${path}: 'all' ve 'any' birlikte`);
+    if (isGroup) {
+        if (hasValue(record.field) || hasValue(record.op) || record.value !== undefined)
+            into.push(`${path}: grup düğümü field/op/value taşıyamaz`);
+        const groupName = record.all !== undefined ? 'all' : 'any';
+        const children = asList(record[groupName]);
+        if (children.length === 0)
+            into.push(`${path}.${groupName}: boş grup`);
+        children.forEach((child, index) => conditionProblems(child, `${path}.${groupName}[${index}]`, depth + 1, counter, into));
+        return;
+    }
+    if (typeof record.field !== 'string' || record.field.trim() === '')
+        into.push(`${path}: 'field' eksik`);
+    const op = typeof record.op === 'string' ? record.op : '';
+    if (!equalityOperators.has(op) && !membershipOperators.has(op) && !comparisonOperators.has(op) && !nullnessOperators.has(op)) {
+        into.push(`${path}: bilinmeyen işleç '${String(record.op)}' (eq · neq · in · notin · lt · lte · gt · gte · isnull · isnotnull)`);
+        return;
+    }
+    const value = record.value;
+    const valueObject = asObject(value);
+    let fits;
+    if (value === undefined || value === null) {
+        fits = nullnessOperators.has(op);
+    }
+    else if (Array.isArray(value)) {
+        fits = membershipOperators.has(op) && value.length > 0 && value.every(item => item === null || typeof item !== 'object');
+    }
+    else if (valueObject && Object.keys(valueObject).length === 1 && typeof valueObject.subject === 'string') {
+        const subject = valueObject.subject;
+        fits = conditionSubjects.has(subject) && (membershipOperators.has(op) ? subject !== 'userId' : equalityOperators.has(op) && subject === 'userId');
+    }
+    else if (valueObject && Object.keys(valueObject).length === 1 && valueObject.now === true) {
+        fits = equalityOperators.has(op) || comparisonOperators.has(op);
+    }
+    else if (valueObject) {
+        fits = false;
+    }
+    else {
+        fits = equalityOperators.has(op) || comparisonOperators.has(op);
+    }
+    if (!fits)
+        into.push(`${path}: değer '${op}' işlecine uymuyor (liste → in/notin; { subject: 'userId' } → eq/neq, diğer özne değişkenleri → in/notin; { now: true } → eq/neq/lt…; değersiz → isnull/isnotnull)`);
+}
+function conditionFields(node, into) {
+    const record = asObject(node);
+    if (!record)
+        return;
+    asList(record.all).forEach(child => conditionFields(child, into));
+    asList(record.any).forEach(child => conditionFields(child, into));
+    if (typeof record.field === 'string' && record.field !== '')
+        into.add(record.field);
+}
+function grantLabel(grant, index) {
+    return `grants[${index}] (${String(grant.permission ?? '?')}${hasValue(grant.resourceKey) ? ` @ ${String(grant.resourceKey)}` : ''})`;
+}
+/**
+ * K-31 anahtarları: `entity:<entityId>` · `field:<entityId>:<fieldId>`; diğer tipler `<tip>:<id>`.
+ * `AccessResource.ReadEntityId` aynası — entity ve alan anahtarından entity id'si okunur.
+ */
+export function entityIdOfResourceKey(key) {
+    if (typeof key !== 'string')
+        return undefined;
+    const segments = key.split(':');
+    if (segments.length < 2 || (segments[0] !== 'entity' && segments[0] !== 'field'))
+        return undefined;
+    return segments[1];
+}
+function grantShape(grants) {
+    const blocks = [];
+    const warnings = [];
+    const seen = new Set();
+    grants.forEach((entry, index) => {
+        const grant = asObject(entry);
+        if (!grant) {
+            blocks.push(`grants[${index}]: nesne değil`);
+            return;
+        }
+        const label = grantLabel(grant, index);
+        const permission = typeof grant.permission === 'string' ? grant.permission : '';
+        const known = knownPermissions.has(permission);
+        const scope = hasValue(grant.scope) ? String(grant.scope) : undefined;
+        const hasCondition = grant.condition !== undefined && grant.condition !== null;
+        if (!known)
+            warnings.push(`${label}: '${permission}' gateway'in izin kataloğunda yok — access_permission_list ile doğrulayın (platform bilinmeyen izne 400 AccessPermissionUnknown döner)`);
+        if (hasValue(grant.resourceKey) && permission !== '') {
+            const type = permission.slice(0, permission.indexOf('.') === -1 ? permission.length : permission.indexOf('.'));
+            const key = String(grant.resourceKey);
+            if (key !== type && !key.startsWith(`${type}:`))
+                blocks.push(`${label}: kaynak anahtarı izin tipiyle uyuşmuyor — '${permission}' için anahtar '${type}:…' olmalı (AccessResourceTypeMismatch)`);
+        }
+        if (grant.effect === 'deny' && hasValue(grant.fieldAccess)) {
+            blocks.push(`${label}: reddet (deny) grant'i alan erişimi taşımaz (AccessDenyFieldAccessNotSupported); kapsam ve koşul taşıyabilir, o zaman eylemi kesmez, yalnız kapsamındaki satırları süzer (K-10); koşulsuz scope: 'all' ise kapsamsız sayılır ve eylemi keser (ACC-042)`);
+        }
+        if (hasCondition && scope === undefined)
+            blocks.push(`${label}: koşul yalnız kapsamla birlikte yazılır, kapsama AND ile eklenir; saf koşul için scope: 'all' (K-11, AccessConditionRequiresScope)`);
+        if (hasValue(grant.subordinatesLine) && scope !== 'subordinates')
+            blocks.push(`${label}: subordinatesLine yalnız scope: 'subordinates' ile (K-33)`);
+        if (scope !== undefined && known && !scopedPermissions.has(permission)) {
+            blocks.push(`${label}: '${permission}' kapsam desteklemiyor — kapsam yalnız ${[...scopedPermissions].join(' · ')} izinlerinde (AccessScopeNotSupported)`);
+        }
+        if (hasValue(grant.fieldAccess) && known && permission !== 'field.read')
+            blocks.push(`${label}: fieldAccess yalnız 'field.read' izninde (AccessFieldAccessNotSupported)`);
+        if (hasCondition && !hasValue(grant.resourceKey))
+            blocks.push(`${label}: koşul alanları grant'in entity/alan anahtarından çözülür — anahtarsız (tipin tamamı) grant'te her koşul alanı 'unknown field' olur (AccessConditionInvalidException)`);
+        if (hasCondition) {
+            const problems = [];
+            conditionProblems(grant.condition, 'condition', 1, { nodes: 0 }, problems);
+            blocks.push(...problems.map(problem => `${label}: ${problem} (AccessConditionInvalidException)`));
+        }
+        const identity = `${permission}|${String(grant.resourceKey ?? '')}|${String(grant.effect ?? '')}`;
+        if (seen.has(identity))
+            blocks.push(`${label}: aynı izin + anahtar + etki ikinci kez yazılmış — platform tekrarlı grant'e 409 (DuplicateException) döner; tek grant'te birleştirin`);
+        seen.add(identity);
+    });
+    return { blocks, warnings };
+}
+function assignmentShape(assignments) {
+    const problems = [];
+    const seen = new Set();
+    assignments.forEach((entry, index) => {
+        const assignment = asObject(entry);
+        if (!assignment)
+            return;
+        const label = `assignments[${index}] (${String(assignment.subjectType ?? '?')} ${String(assignment.subjectId ?? '?')})`;
+        if (assignment.includeDescendants === true && assignment.subjectType !== 'unit')
+            problems.push(`${label}: includeDescendants yalnız subjectType: 'unit' ile (AccessAssignmentDescendantsRequiresUnit)`);
+        if (typeof assignment.startsAt === 'string' && typeof assignment.endsAt === 'string' && Date.parse(assignment.endsAt) <= Date.parse(assignment.startsAt)) {
+            problems.push(`${label}: endsAt startsAt'ten sonra olmalı (AccessAssignmentPeriodInvalid)`);
+        }
+        const identity = `${String(assignment.subjectType)}|${String(assignment.subjectId)}`;
+        if (seen.has(identity))
+            problems.push(`${label}: aynı özne ikinci kez atanmış — platform 409 döner`);
+        seen.add(identity);
+    });
+    return problems;
+}
+const protectedModes = new Set(['masked', 'encrypted', 'masked-encrypted']);
+const FALLBACK_MASK_TYPES = ['last-n', 'first-n', 'first-last', 'email', 'phone', 'full', 'pattern', 'first-n-last-n'];
+/** Backend `FieldProtectionConstants.PhoneSeparatorCharacters`: telefon maskesinde bu karakterler (ve boşluk) maske karakteri olamaz. */
+const PHONE_SEPARATOR_CHARACTERS = '+-()./';
+/**
+ * Maske türleri paketlenmiş şemanın `FieldMaskType` enum'undan (`refresh-schemas`): tür listesi backend'le tek
+ * kaynaktan gelir, yeni tür için gateway'de liste güncellenmez (kök docs/adr/0001, `rowFilterEnums` emsali).
+ * Türe özgü sayı kuralları PROT-003'te kalır. Dosya okunamazsa (bozuk paket) bugünkü liste.
+ */
+export function protectionMaskTypes(schemaPath = join(dirname(fileURLToPath(import.meta.url)), '..', 'resources', 'schemas', 'CreateEntityCommand.json')) {
+    try {
+        const schemas = JSON.parse(readFileSync(schemaPath, 'utf8')).components?.schemas ?? {};
+        const values = Object.entries(schemas).find(([name]) => name.endsWith('.FieldMaskType'))?.[1]?.enum;
+        return values && values.length > 0 ? values : FALLBACK_MASK_TYPES;
+    }
+    catch {
+        return FALLBACK_MASK_TYPES;
+    }
+}
+const maskTypes = new Set(protectionMaskTypes());
+const derivationTypes = new Set(['slice', 'regex', 'domain']);
+function protectionMode(field) {
+    const mode = asObject(field.protection)?.mode;
+    return typeof mode === 'string' && protectedModes.has(mode) ? mode : undefined;
+}
+function fieldLabel(field, index) {
+    return `fields[${index}] '${String(field.slug ?? field.id ?? '?')}'`;
+}
+function protectionProblems(fields) {
+    const problems = [];
+    fields.forEach((field, index) => {
+        const mode = protectionMode(field);
+        if (!mode)
+            return;
+        const label = fieldLabel(field, index);
+        const reasons = [
+            ...(field.commonType !== undefined && field.commonType !== 'text' ? [`commonType '${String(field.commonType)}' (yalnız 'text')`] : []),
+            ...(field.display === true ? ['display alanı'] : []),
+            ...(field.primaryKey === true ? ['primaryKey'] : []),
+            ...(field.identity === true ? ['identity'] : []),
+            ...(field.isLocalized === true ? ['isLocalized'] : []),
+            ...((hasValue(field.relationType) && field.relationType !== 'none') || hasValue(field.relationId) ? ['ilişki alanı'] : [])
+        ];
+        if (reasons.length > 0)
+            problems.push(`${label}: korunamaz — ${reasons.join(', ')} (ProtectionFieldTypeNotSupported / ProtectionDisplayFieldNotAllowed)`);
+        const mask = asObject(asObject(field.protection)?.mask);
+        if ((mode === 'masked' || mode === 'masked-encrypted') && !mask) {
+            problems.push(`${label}: '${mode}' modunda protection.mask zorunlu ({ type: 'last-n', visible: 4 } gibi)`);
+        }
+        else if (mask) {
+            const type = String(mask.type ?? '');
+            const visible = typeof mask.visible === 'number' ? mask.visible : 0;
+            const visibleEnd = typeof mask.visibleEnd === 'number' ? mask.visibleEnd : 0;
+            const maskCharacter = typeof mask.char === 'string' && mask.char !== '' ? mask.char.charAt(0) : '*';
+            if (!maskTypes.has(type))
+                problems.push(`${label}: mask.type '${type}' geçersiz (${[...maskTypes].join(' · ')})`);
+            if ((type === 'last-n' || type === 'first-n' || type === 'first-n-last-n') && visible <= 0)
+                problems.push(`${label}: mask.type '${type}' visible > 0 ister`);
+            if (type === 'first-n-last-n' && visibleEnd <= 0)
+                problems.push(`${label}: mask.type 'first-n-last-n' visibleEnd > 0 ister (visible baştan, visibleEnd sondan görünen karakter sayısı)`);
+            if (type === 'pattern' && !hasValue(mask.pattern))
+                problems.push(`${label}: mask.type 'pattern' mask.pattern ister ('#' açık karakter)`);
+            if (type === 'phone' && (/\s/.test(maskCharacter) || PHONE_SEPARATOR_CHARACTERS.includes(maskCharacter)))
+                problems.push(`${label}: mask.type 'phone' mask.char '${maskCharacter}' olamaz — ayırıcı ya da boşluk (${PHONE_SEPARATOR_CHARACTERS}) maske karakteri olursa geri yazılan maske gerçek değerin yerine geçer`);
+        }
+    });
+    return problems;
+}
+function derivationProblems(fields) {
+    const blocks = [];
+    const warnings = [];
+    fields.forEach((field, index) => {
+        const hasSource = hasValue(field.derivedFromFieldId);
+        const rule = asObject(field.derivationRule);
+        if (!hasSource && !rule)
+            return;
+        const label = fieldLabel(field, index);
+        if (hasSource !== Boolean(rule)) {
+            blocks.push(`${label}: türetilmiş alan derivedFromFieldId VE derivationRule ister — ikisi birlikte verilir (ProtectionDerivedSourceInvalid)`);
+            return;
+        }
+        if (hasValue(field.id) && field.derivedFromFieldId === field.id)
+            blocks.push(`${label}: alan kendisinden türetilemez (ProtectionDerivedSourceInvalid)`);
+        if (field.commonType !== undefined && field.commonType !== 'text')
+            blocks.push(`${label}: türetilmiş alan yalnız 'text' olabilir`);
+        const type = String(rule.type ?? '');
+        const start = typeof rule.start === 'number' ? rule.start : 0;
+        const length = typeof rule.length === 'number' ? rule.length : 0;
+        if (!derivationTypes.has(type))
+            blocks.push(`${label}: derivationRule.type '${type}' geçersiz (slice · regex · domain) (ProtectionDerivedRuleInvalid)`);
+        if (start < 0)
+            blocks.push(`${label}: derivationRule.start negatif olamaz (ProtectionDerivedRuleInvalid)`);
+        if (length < 0 || (type === 'slice' && length === 0))
+            blocks.push(`${label}: 'slice' kuralı length > 0 ister (ProtectionDerivedRuleInvalid)`);
+        if (type === 'regex') {
+            if (!hasValue(rule.pattern)) {
+                blocks.push(`${label}: 'regex' kuralı pattern ister (ProtectionDerivedRuleInvalid)`);
+            }
+            else {
+                try {
+                    new RegExp(String(rule.pattern));
+                }
+                catch {
+                    warnings.push(`${label}: pattern JavaScript'te derlenmedi; platform .NET Regex'le derler — .NET'e özgü sözdizimi değilse düzeltin (ProtectionDerivedRuleInvalid)`);
+                }
+            }
+        }
+    });
+    return { blocks, warnings };
+}
+function systemEntityWriteMessage(entity, operation) {
+    const verb = operation === 'delete' ? 'row_delete' : operation === 'update' ? 'row_update' : 'row_create';
+    const owner = entity.group === 'organization'
+        ? "Kompleks projede ağaç organizasyonun yayınlanmış şemasından senkronla gelir (yönetim konsolu → yayın); projeye özel birim/pozisyon ve kullanıcı ataması Studio › Organizasyon ekranından yapılır — MCP'de bu yazma yolu yoktur ve bilinçli olarak açılmadı (yapı yazımı aboneliği kapatır, dal ortamında 409)."
+        : "Policy, grant ve atama access_policy_create / access_policy_update ile yazılır; izin kataloğu ve kaynak kataloğu platformun kendisi tarafından tohumlanır.";
+    return `'${entity.slug}' platformun yönettiği hazır bir entity'dir; ${verb} ile yazılamaz — platform 400 SystemEntityWriteNotAllowed döner (genel satır uçları, table kaynaklı uç ve table step'te aynı kapı). ${owner} Okumak serbesttir: row_list('${entity.slug}'). Rehber: platform_guide('access') §'Organizasyon ağacı'.`;
+}
+/** ORG-001 bulgusu: kural ham `entityId`'yi, `rows.ts` çözülen id'yi aynı fonksiyonla denetler. */
+export function systemEntityWriteFindings(ref, operation) {
+    const entity = systemManagedEntity(ref);
+    return entity
+        ? [{ ruleId: 'ORG-001', severity: 'block', message: systemEntityWriteMessage(entity, operation), guide: 'ngapps://guides/access' }]
+        : [];
+}
+function workflowSteps(definition) {
+    return [...asList(definition.steps), ...asList(asObject(definition.automation)?.steps)]
+        .map(step => asObject(step))
+        .filter((step) => Boolean(step));
+}
+/**
+ * Projenin türü ve ortamın zorlama modu (`GET /p/{slug}` → `accessModel`, `environments[].enforcementMode`).
+ * Okuma düşerse `undefined`: teşhis alanları susar, çağrının kendisi etkilenmez.
+ */
+export async function projectAccessContext(platform, project, environment) {
+    try {
+        const payload = await platform.org('GET', `/p/${platform.resolveProject(project)}`);
+        const data = asObject(payload?.data) ?? {};
+        const name = platform.resolveEnvironment(environment);
+        const current = asList(data.environments).map(entry => asObject(entry)).find(entry => entry?.name === name);
+        return {
+            accessModel: typeof data.accessModel === 'string' ? data.accessModel : 'simple',
+            ...(typeof current?.enforcementMode === 'string' ? { enforcementMode: current.enforcementMode } : {}),
+            environment: name
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+const runtimeDenials = {
+    AppSessionRequiredException: {
+        reason: "oturum yok — kompleks proje + enforce ortamda oturumsuz her microservice ve sayfa isteği 401 döner (anonim uç işareti yok)",
+        next: "parolasız kullanıcı gözü için aynı çağrıyı asUserId (users satır id'si; development/dal) ile tekrarlayın; oturum açılmış üye için access_session_create ile giriş yapıp tokenRefs'teki tok_… değerini asUser olarak verin"
+    },
+    AppSessionInvalidException: {
+        reason: 'uygulama jetonu geçersiz, süresi dolmuş (15 dk) ya da iptal edilmiş',
+        next: 'access_session_create ile yeniden giriş yapın'
+    },
+    CsrfTokenMismatchException: {
+        reason: "oturum çerezle geldi ve durum değiştiren istekte X-ZY-CSRF başlığı yok ya da yanlış",
+        next: "asUser kullanın: jeton Bearer olarak gider ve Bearer'lı istek CSRF istemez"
+    },
+    ForbiddenException: {
+        reason: 'karar motoru izni reddetti',
+        next: "access_preview { userId, permission, resourceKey } ile hangi atamanın/grant'in eksik olduğunu görün"
+    },
+    AccessQueryNotScopedException: {
+        reason: "sorgu kaynaklı uç ya da query adımı kapsamlı/korumalı bir tabloya dokunuyor ve sorgu isUnrestricted değil",
+        next: "kullanıcıya özel veri için table kaynağına geçin; tüm veriyi özetleyen rapor ise sorguyu isUnrestricted işaretleyin (ACC-005)"
+    },
+    AccessFieldWriteDeniedException: {
+        reason: 'kullanıcının yazma yetkisi olmayan bir alana değer gönderildi',
+        next: 'gövdeden alanı çıkarın ya da field.read / entity.update grant\'ini gözden geçirin (access_preview fieldAccess.canWrite)'
+    },
+    AccessFilterDeniedException: {
+        reason: 'kullanıcının filtre yetkisi olmayan (canFilter: false) bir alana filtre yazıldı',
+        next: "access_preview fieldAccess.canFilter; korumalı alanda tam eşleşme için field.filter izni"
+    },
+    AccessRevealDeniedException: {
+        reason: "reveal izni yok, proje basit ya da zorlama modu off",
+        next: 'entity.reveal grant\'i (kapsamlı) ve enforce/shadow mod'
+    }
+};
+/**
+ * Microservice ve sayfa yanıtına eklenen `accessDecision`: platform kararı yanıtta ayrı bir alan olarak
+ * gelmez, hata kodundan ve ortamın modundan türetilir. Basit projede ve erişimle ilgisiz hatada `undefined`.
+ */
+export function accessDecisionOf(context, status, code, message) {
+    if (!context || context.accessModel !== 'complex')
+        return undefined;
+    const mode = context.enforcementMode ?? 'bilinmiyor';
+    const denial = typeof code === 'string' ? runtimeDenials[code] : undefined;
+    if (denial) {
+        // İzin yalnız ForbiddenException'da ve ham platform mesajında TAM sözcük olarak aranır: alt dize eşleşmesi
+        // `microfunction.execute` içinde `function.execute` bulur, gateway ipucu metni ise ('entity.reveal grant'i')
+        // başka kodlarda yanlış izin yazdırır. Bugünkü backend mesajı slug taşımaz (`ForbiddenException` kaynağı
+        // parametresiz yerelleşir); bulunamazsa alan yazılmaz.
+        const tokens = code === 'ForbiddenException' && typeof message === 'string' ? message.match(/(?<![\w.-])[a-z][a-z-]*(?:\.[a-z][a-z-]*)+/g) ?? [] : [];
+        const permission = tokens.find(token => knownPermissions.has(token));
+        return { decision: 'deny', status, code, mode, ...(permission ? { permission } : {}), reason: denial.reason, next: denial.next };
+    }
+    if (typeof status === 'number' && status >= 400) {
+        return status === 404 && mode === 'enforce'
+            ? { decision: 'unknown', status, mode, reason: 'kayıt yok ya da çağıranın satır kapsamı dışında — platform kapsam dışı kaydı 404 ile gizler (varlık sızdırmaz)', next: 'access_preview { userId, permission, resourceKey, rowId }' }
+            : undefined;
+    }
+    return {
+        decision: mode === 'enforce' ? 'allow' : 'not-enforced',
+        status,
+        mode,
+        reason: mode === 'enforce'
+            ? 'karar motoru izin verdi; satırlar kapsamla SQL\'de süzülmüş, alanlar erişim düzeyine göre dönmüş olabilir'
+            : mode === 'shadow'
+                ? "gölge mod: istek engellenmedi; zorunlu olsaydı reddedilecek ya da süzülecek istekler karar günlüğüne yazılır"
+                : "zorlama kapalı: karar motoru devrede değil, kimlik ve yetki uygulamanın kendi middleware'inde"
+    };
+}
+/** `AccessResourceRef.TryParse` aynası: tip tek başına ya da tipe göre GUID segmentleri. */
+export function resourceKeyProblem(key) {
+    const parts = key.split(':');
+    const type = parts[0] ?? '';
+    const references = parts.slice(1);
+    const guid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    if (parts.some(part => part.trim() === ''))
+        return `'${key}': anahtarda boş segment var`;
+    if (!accessResourceTypes.includes(type))
+        return `'${key}': bilinmeyen kaynak tipi '${type}' (${accessResourceTypes.join(' · ')})`;
+    if (references.length === 0)
+        return undefined;
+    const valid = type === 'entity'
+        ? references.length === 1 && guid.test(references[0])
+        : type === 'field'
+            ? references.length === 2 && references.every(reference => guid.test(reference))
+            : type === 'row'
+                ? references.length === 2 && guid.test(references[0])
+                : references.every(reference => guid.test(reference));
+    return valid ? undefined : `'${key}': biçim geçersiz — 'entity:<entityId>' · 'field:<entityId>:<fieldId>' · 'row:<entityId>:<rowId>' · '<tip>:<id>' ya da yalnız '<tip>' (AccessResourceKeyInvalid)`;
+}
+/**
+ * ACC-006: kompleks projede kimliği platform kurar (uygulama oturumu → güvenilir özne → uç yolunda `user`
+ * değişkeni). Bağlı middleware'ler zorlama modundan bağımsız her modda koşar (`ExecuteMicroserviceBehavior`
+ * ve `ExecutePageBehavior` middleware döngüsünde mod dallanması yok): set-user adımı (`SetUserStep`) ya da
+ * middleware yanıtındaki `user` platformun `user`'ını ezer ve yanlış bir ikinci doğruluk kaynağı olur. Rol
+ * listesi hiçbir modda karar girdisi değildir — yalnız `triggerSource.roles` → `Authorized(user.roles)`.
+ * Projenin türü gövdeden okunamaz; yalnız set-user'lı middleware yazımında okunur.
+ */
+export async function identityMiddlewareFindings(platform, project, environment, definition, kind, policyOverride = false) {
+    if (platform.config.policyMode === 'off')
+        return [];
+    if ((kind ?? definition.type) !== 'middleware')
+        return [];
+    if (!workflowSteps(definition).some(step => step.type === 'set-user'))
+        return [];
+    const context = await projectAccessContext(platform, project, environment);
+    if (context?.accessModel !== 'complex')
+        return [];
+    return applyPolicyMode(platform.config, [{
+            ruleId: 'ACC-006',
+            severity: 'warn',
+            message: "Kompleks projede kimlik middleware'i gereksizdir ve bağlı kalırsa etkisiz DEĞİLDİR. Platform uygulama oturumunu kendisi yönetir (POST /{proje}/runtime/{app}/auth/sign-in, çerez ZY_App_{proje}) ve uç yolunda 'user' değişkenini (id, email, roles, roles_csv, positions, units) güvenilir özneyle ÖNCEDEN doldurur. Uca ya da sayfaya bağlı middleware'ler zorlama modundan bağımsız HER MODDA koşar ve reddedebilir; set-user adımı ya da middleware yanıtındaki 'user' platformun 'user'ını EZER — karar motoru özneyi oturumdan okur, ama ifadeler artık ikinci bir kimliği görür. Kimlik middleware'ini uçların ve sayfaların middlewareIds'inden çıkarın. Yetki erişim politikasıyla verilir: platform microservice.roles / page.roleIds rol listesini hiçbir modda karar için kullanmaz (liste yalnız Authorized(user.roles) çağıran middleware'de okunur). Ayar setter'ı gibi kimlik dışı middleware'ler serbesttir.",
+            guide: 'ngapps://guides/access'
+        }], policyOverride);
+}
+/**
+ * ACC-008: kompleks projede eski rol listeleri (`page.roleIds`, `microservice.roles`) karar girdisi
+ * DEĞİLDİR — `enforce`'ta tek kapı PDP'dir (K-29). Liste yalnız `triggerSource.roles`'a geçer ve
+ * `Authorized(user.roles)` çağıran bir middleware okur; dolu bırakmak ikinci bir doğruluk kaynağı
+ * görüntüsü verir. Block değil warn: `off` ve `shadow` modunda eski davranış sürer, yani liste hâlâ
+ * anlamlı olabilir. Studio karşılığı `showsLegacyRoleSelector` — seçici kompleks projede çizilmez.
+ *
+ * Gövdede rol listesi yoksa proje türü hiç sorulmaz; tur maliyeti yalnız dolu listede ödenir.
+ */
+export async function legacyRoleListFindings(platform, project, environment, definition, surface, policyOverride = false) {
+    if (platform.config.policyMode === 'off')
+        return [];
+    const roleIds = definition.roleIds ?? definition.roles;
+    if (!Array.isArray(roleIds) || roleIds.length === 0)
+        return [];
+    const context = await projectAccessContext(platform, project, environment);
+    if (context?.accessModel !== 'complex')
+        return [];
+    const field = surface === 'page' ? 'page.roleIds' : 'microservice.roles';
+    return applyPolicyMode(platform.config, [{
+            ruleId: 'ACC-008',
+            severity: 'warn',
+            message: `Kompleks projede '${field}' rol listesi KARAR GİRDİSİ DEĞİLDİR: zorlama açıkken (enforce) tek kapı karar motorudur ve platform bu listeyi hiçbir modda yetki için okumaz (K-29). Liste yalnız triggerSource.roles'a geçer, yani ona bir anlam veren tek şey Authorized(user.roles) çağıran bir middleware'dir — o da yoksa ${roleIds.length} rol sessizce etkisizdir ve bakan kişiye ikinci bir doğruluk kaynağı gibi görünür. Yetkiyi erişim politikasıyla verin: access_policy_create / access_matrix_save ile '${surface === 'page' ? 'page.view' : 'microservice.execute'}' iznini tanımlayın, atamayı access_matrix_save ile role/pozisyona bağlayın. Listeyi boşaltın (roleIds: []) ya da bilinçli tutuyorsanız bu uyarıyı yok sayın — 'off' ve 'shadow' modunda eski davranış sürüyor. Studio bu projede rol seçicisini zaten çizmez. Reçete: platform_guide('access') §Eski rol listeleri.`,
+            guide: 'ngapps://guides/access'
+        }], policyOverride);
+}
+/** PROT-003'ün gövdesi; `entity_protection_update` tek alan için aynı denetimi kullanır. */
+export function fieldProtectionFindings(fields) {
+    const problems = protectionProblems(fields.map(field => asObject(field) ?? {}));
+    return problems.length > 0
+        ? [{ ruleId: 'PROT-003', severity: 'block', message: `Alan koruması bu alana uygulanamaz:\n  · ${problems.join('\n  · ')}\nKoruma yalnız düz METİN alana (display, birincil anahtar, identity, çok dilli ve ilişki alanı olmayan) konur.`, guide: 'ngapps://guides/access' }]
+        : [];
+}
+/**
+ * `FieldProtection.HasSameDefinition` aynası: mod, exactSearch, normalize ve maske. Korumasız alan
+ * (`null` ya da `mode: 'none'`) tek imzaya iner; maske karakteri verilmezse platform varsayılanı `*`.
+ */
+function protectionSignature(value) {
+    const protection = asObject(value);
+    const mode = typeof protection?.mode === 'string' ? protection.mode : 'none';
+    if (mode === 'none')
+        return 'none';
+    const mask = asObject(protection?.mask);
+    return JSON.stringify([mode, protection?.exactSearch === true, protection?.normalize ?? 'none', mask ? [mask.type ?? null, mask.visible ?? 0, mask.visibleEnd ?? 0, mask.char ?? '*', mask.pattern ?? null] : null]);
+}
+/**
+ * Güncelleme yolu VAR OLAN alanın korumasını değiştiremez: `EntityService` gelen alanın
+ * `protection`'ı doluysa ve saklananla aynı tanım değilse `ProtectionChangeNotAllowedException`
+ * atar — dolu satırlar arka plan işiyle dönüştürülmelidir (`POST …/fields/{fieldId}/protection`).
+ * Alan id'siyle eşlenir; gövdede `protection` taşımayan alan platformda da değişmiş sayılmaz.
+ */
+export function changedExistingProtections(before, after) {
+    const previous = new Map(asList(asObject(before)?.fields)
+        .map(field => asObject(field))
+        .filter((field) => Boolean(field) && hasValue(field.id))
+        .map(field => [String(field.id), field]));
+    return asList(asObject(after)?.fields)
+        .map(field => asObject(field))
+        .filter((field) => Boolean(field) && previous.has(String(field.id)) && field.protection !== undefined && field.protection !== null)
+        .filter(field => protectionSignature(previous.get(String(field.id)).protection) !== protectionSignature(field.protection))
+        .map(field => String(field.slug ?? field.id));
+}
+export function accessPolicyRules() {
+    return [
+        {
+            id: 'ORG-001',
+            module: 'row',
+            appliesTo: ['create', 'update', 'delete'],
+            sourceRef: "EntityService.cs (CreateRow/UpdateRow/DeleteRow/bulk yolları): Defaults.SystemManagedEntityIds.Contains(entityDto.Id) ⇒ InvalidParameterException(SystemEntityWriteNotAllowed); küme EntityConstants.cs OrganizationStructureEntityIds + AccessEntityIds (b-13, 05 §3.1)",
+            check: (definition, context) => systemEntityWriteFindings(definition.entityId, context.operation)
+        },
+        {
+            id: 'ACC-001',
+            module: 'accessPolicy',
+            appliesTo: ['create', 'update'],
+            sourceRef: "AccessGrant ctor (K-10 deny kapsam taşıyabilir, yalnız fieldAccess yasak; K-11 koşul kapsamla, K-33 subordinatesLine) + AccessGrant.EnsureMatchesPermission (AccessScopeNotSupported, AccessFieldAccessNotSupported, AccessResource.EnsureKeyBelongsToType) + ConditionNodeValidator (derinlik 5, düğüm 50, işleç/değer) + AccessAssignment kuralları; izin kataloğu AccessPermissionConstants (b-22)",
+            check: definition => {
+                const grant = grantShape(asList(definition.grants));
+                const assignment = assignmentShape(asList(definition.assignments));
+                const blocks = [...grant.blocks, ...assignment];
+                return [
+                    ...(blocks.length > 0 ? [{ ruleId: 'ACC-001', severity: 'block', message: `Policy gövdesi platformun grant/atama kurallarına uymuyor (platform reddeder — biçim hataları 400, tekrarlı grant/atama 409 DuplicateException):\n  · ${blocks.join('\n  · ')}`, guide: 'ngapps://guides/access' }] : []),
+                    ...(grant.warnings.length > 0 ? [{ ruleId: 'ACC-001', severity: 'warn', message: grant.warnings.join(' · '), guide: 'ngapps://guides/access' }] : [])
+                ];
+            }
+        },
+        {
+            id: 'ORG-003',
+            module: 'userPosition',
+            appliesTo: ['update'],
+            sourceRef: "UserPosition ctor/SetPeriod (UserPositionPeriodInvalid) + UserPosition.EnsureSinglePrimary (UserPositionPrimaryDuplicate) + UserPosition.EnsureSeatAvailable (OrganizationPositionSeatOccupied, 409 — tek koltuklu pozisyonda çakışan ikinci KALICI atama; TB-96)",
+            check: definition => {
+                const positions = asList(definition.positions)
+                    .map(entry => asObject(entry))
+                    .filter((position) => position !== undefined && position !== null);
+                const problems = [];
+                const seen = new Set();
+                positions.forEach((position, index) => {
+                    const endsAt = position.endsAt;
+                    if (typeof endsAt !== 'string')
+                        return;
+                    const startsAt = typeof position.startsAt === 'string' ? Date.parse(position.startsAt) : Date.now();
+                    if (Date.parse(endsAt) <= startsAt) {
+                        problems.push(`positions[${index}]: endsAt startsAt'ten sonra olmalı (UserPositionPeriodInvalid) — startsAt verilmezse platform ŞİMDİ uygular`);
+                    }
+                });
+                positions.forEach((position, index) => {
+                    const identity = `${String(position.positionId)}|${String(position.assignmentType ?? 'permanent')}`;
+                    if (seen.has(identity))
+                        problems.push(`positions[${index}]: aynı pozisyona aynı türde ikinci atama — platform 409 döner (UserPosition.EnsureSinglePrimary)`);
+                    seen.add(identity);
+                });
+                if (positions.filter(position => position.isPrimary === true).length > 1) {
+                    problems.push('Bir kullanıcının en çok bir birincil ataması olur (UserPositionPrimaryDuplicate)');
+                }
+                return problems.length === 0
+                    ? []
+                    : [{ ruleId: 'ORG-003', severity: 'block', message: `Atama listesi platformun kurallarına uymuyor (istek gönderilmedi):\n  · ${problems.join('\n  · ')}`, guide: 'ngapps://guides/access' }];
+            }
+        },
+        {
+            id: 'ACC-009',
+            module: 'accessPolicy',
+            appliesTo: ['create', 'update'],
+            sourceRef: "AccessAssignment ctor/Override/SetPeriod: OverridesDeny yalnız SubjectType == User ve dolu EndsAt ile (AccessOverrideRequiresUserWithEndDate, 400); yazmak AccessPolicyService.EnsureOverrideAllowed üzerinden access.override.manage izni ister (AccessOverridePermissionRequiredException, 403) — istisnanın öznesini değiştirmek ve aktif istisna taşıyan politikanın grant kümesine dokunmak (ekleme · silme · değiştirme, access_matrix_save dâhil) aynı izni ister; karar motorunda AccessDecisionResolver.HasOverride bütün deny'leri düşürür ve reason 'allowed-by-override' olur (TB-95)",
+            check: definition => {
+                const overrides = asList(definition.assignments)
+                    .map((entry, index) => ({ assignment: asObject(entry), index }))
+                    .filter(entry => entry.assignment?.overridesDeny === true);
+                const malformed = overrides.filter(entry => entry.assignment?.subjectType !== 'user' || !hasValue(entry.assignment?.endsAt));
+                if (malformed.length > 0) {
+                    return [{
+                            ruleId: 'ACC-009',
+                            severity: 'block',
+                            message: `overridesDeny yalnız subjectType: 'user' ve dolu endsAt ile yazılır (AccessOverrideRequiresUserWithEndDate, 400 — istek gönderilmedi):\n  · ${malformed.map(entry => `assignments[${entry.index}] (${String(entry.assignment?.subjectType ?? '?')} ${String(entry.assignment?.subjectId ?? '?')})`).join('\n  · ')}`,
+                            guide: 'ngapps://guides/access'
+                        }];
+                }
+                return overrides.length === 0
+                    ? []
+                    : [{
+                            ruleId: 'ACC-009',
+                            severity: 'warn',
+                            message: `Bu istek ${overrides.length} kullanıcı istisnası yazıyor (overridesDeny). İstisna hem kapsamlı hem kapsamsız bütün deny'leri düşürür ve açıklamada reason 'allowed-by-override' olur; yazmak access.override.manage izni ister — 403 alırsanız izni olan hesapla tekrarlayın. İstisna taşıyan politikanın grant'lerine dokunmak da aynı izni ister (access_matrix_save dâhil): istisna o grant kümesi kadar yasak aşar, küme değişince istisnanın sınırı da değişir. Süre dolunca istisna kendiliğinden düşer, bu yüzden endsAt zorunludur.`,
+                            guide: 'ngapps://guides/access'
+                        }];
+            }
+        },
+        {
+            id: 'ACC-004',
+            module: 'workflow',
+            appliesTo: ['create', 'update', 'preview'],
+            sourceRef: "TableStep.cs / QueryStep.cs: rule.RunAs == StepRunAs.System ⇒ accessEnforcementService.Suppress() — satır kapsamı, alan erişimi ve ham SQL guard'ı atlanır; StepRunAs.TriggeringUser ⇒ RunAsTriggeringUser() — otomasyonda tetikleyen kullanıcının kapsamı geri gelir (AutomationConsumer aktörü çözüp özneye koyar); system adımı denetim kaydı yazmaz (TB-45); runAs StepRuleDto ile taşınır, lint gövdeden okur",
+            check: definition => {
+                const steps = workflowSteps(definition).filter(step => step.type === 'table' || step.type === 'query');
+                const unexplained = steps.filter(step => asObject(step.rule)?.runAs === 'system' && !(typeof step.caution === 'string' && step.caution.trim() !== ''));
+                const triggering = steps.filter(step => asObject(step.rule)?.runAs === 'triggering-user');
+                const label = (step) => String(step.name ?? step.id ?? step.type);
+                return [
+                    ...(unexplained.length > 0 ? [{ ruleId: 'ACC-004', severity: 'warn', message: `runAs: 'system' adımı gerekçesiz: ${unexplained.map(label).join(', ')}. Bu adım kompleks projede satır kapsamını, alan erişimini ve ham SQL korumasını ATLAR — çağıranın göremediği satırları okur/yazar ve platform bunun için denetim kaydı yazmaz. Gerçekten gerekiyorsa (sayaç, sistem özeti) nedenini adımın 'caution' alanına yazın; kural o zaman susar. Çoğu adım için doğrusu 'inherit'tir (varsayılan).`, guide: 'ngapps://guides/access' }] : []),
+                    ...(triggering.length > 0 ? [{ ruleId: 'ACC-004', severity: 'warn', message: `runAs: 'triggering-user' adımı tetikleyen kullanıcının kapsamıyla koşar: ${triggering.map(label).join(', ')}. Otomasyon zincirinde aktör çözülemezse (zamanlanmış iş, sistem tetikleyicisi) adım 'inherit' gibi davranır ve system öznesiyle koşar. Ayırım önemliyse platform_guide('access') §'Kısıtsız sorgu ve runAs'.`, guide: 'ngapps://guides/access' }] : [])
+                ];
+            }
+        },
+        {
+            id: 'ACC-005',
+            module: 'query',
+            appliesTo: ['create', 'update'],
+            sourceRef: "AccessEnforcementService.EnsureQueryScopedAsync(rawQuery, datasourceId, isUnrestricted): işaretsiz sorgu kapsamlı/korumalı entity slug'ını metinde geçirirse 403 AccessQueryNotScoped (sezgisel eşleşme, TB-49); işareti koymak query.unrestricted iznini denetlemez (TB-43), yürütme denetim kaydı yazmaz (TB-45)",
+            check: definition => definition.isUnrestricted === true
+                ? [{ ruleId: 'ACC-005', severity: 'warn', message: "isUnrestricted: true — bu sorgu kompleks projede satır kapsamını ve alan korumasını HİÇ uygulamadan çalışır: onu çağıran her kullanıcı sahiplik alanlı tablonun bütün satırlarını görür. İşareti koymak şu an bir izin kapısından geçmez ve yürütme denetim kaydı bırakmaz. Yalnız gerçekten tüm veriyi özetlemesi gereken rapor için kullanın; kullanıcıya özel liste table kaynaklı uçla ya da workflow table adımıyla kurulur (kapsam SQL'de uygulanır).", guide: 'ngapps://guides/access' }]
+                : []
+        },
+        {
+            id: 'PROT-003',
+            module: 'entity',
+            appliesTo: ['create', 'update'],
+            sourceRef: 'FieldDtoValidator When(Protection.Mode != None): CommonType == Text, Display/PrimaryKey/Identity/IsLocalized false, Mask NotNull (masked*); Field.EnsureProtectable (ilişki alanı); FieldMaskRule ctor (last-n/first-n visible > 0, first-n-last-n visible ve visibleEnd > 0, pattern zorunlu, phone mask.char ayırıcı/boşluk olamaz)',
+            check: definition => fieldProtectionFindings(asList(definition.fields))
+        },
+        {
+            id: 'PROT-004',
+            module: 'entity',
+            appliesTo: ['create', 'update'],
+            sourceRef: 'FieldDtoValidator When(DerivedFromFieldId || DerivationRule): ikisi birlikte + CommonType Text; Field.SetDerivation (kendisinden türetme yok); FieldDerivationRule ctor (start ≥ 0, slice length > 0, regex pattern derlenir)',
+            check: definition => {
+                const { blocks, warnings } = derivationProblems(asList(definition.fields));
+                return [
+                    ...(blocks.length > 0 ? [{ ruleId: 'PROT-004', severity: 'block', message: `Türetilmiş alan kuralı geçersiz:\n  · ${blocks.join('\n  · ')}`, guide: 'ngapps://guides/access' }] : []),
+                    ...(warnings.length > 0 ? [{ ruleId: 'PROT-004', severity: 'warn', message: warnings.join(' · '), guide: 'ngapps://guides/access' }] : [])
+                ];
+            }
+        }
+    ];
+}
+async function entityShape(resolver, entityRef) {
+    try {
+        const ref = await resolver.entity(entityRef);
+        const record = await resolver.entityRecord(ref);
+        const fields = asList(record.fields).map(field => asObject(field) ?? {});
+        return {
+            slug: ref.slug,
+            protectedSlugs: new Set(fields.filter(field => protectionMode(field)).map(field => String(field.slug))),
+            conditionSlugs: new Set(fields.filter(field => !protectionMode(field) && field.isSystemField !== true && field.hidden !== true).map(field => String(field.slug))),
+            hasOwnerFields: fields.some(field => field.slug === 'sys_owner_user_id'),
+            fieldSlugById: new Map(fields.filter(field => typeof field.id === 'string').map(field => [String(field.id), { slug: String(field.slug), isProtected: protectionMode(field) !== undefined }]))
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * ACC-002 ve ACC-003 gövdeden anlaşılamaz: entity'nin alanlarına (koruma, sahiplik alanı) bakmak
+ * gerekir. Gateway yalnız KAPSAMLI ya da KOŞULLU grant'lerin entity'lerini okur; okuma düşerse
+ * kural susar — ön denetim bir kolaylıktır, yazmayı kendi arızası yüzünden engellemez.
+ */
+export async function accessPolicyEntityFindings(platform, resolver, body) {
+    if (platform.config.policyMode === 'off')
+        return [];
+    const grants = asList(body.grants).map(entry => asObject(entry)).filter((grant) => Boolean(grant));
+    const isMaskGrant = (grant) => grant.effect !== 'deny' && grant.permission === 'field.read' && grant.fieldAccess === 'masked' && typeof grant.resourceKey === 'string' && grant.resourceKey.split(':').length === 3;
+    const relevant = grants.filter(grant => grant.effect !== 'deny' && ((grant.condition !== undefined && grant.condition !== null) || (hasValue(grant.scope) && grant.scope !== 'all') || isMaskGrant(grant)));
+    const shapes = new Map();
+    const protectedHits = [];
+    const unknownFields = [];
+    const withoutOwner = [];
+    const unprotectedMasks = [];
+    for (const grant of relevant) {
+        const entityId = entityIdOfResourceKey(grant.resourceKey);
+        if (!entityId)
+            continue;
+        if (!shapes.has(entityId))
+            shapes.set(entityId, await entityShape(resolver, entityId));
+        const shape = shapes.get(entityId);
+        if (!shape)
+            continue;
+        const label = `${String(grant.permission)} @ ${String(grant.resourceKey)}`;
+        const fields = new Set();
+        conditionFields(grant.condition, fields);
+        for (const field of fields) {
+            if (shape.protectedSlugs.has(field))
+                protectedHits.push(`${label}: '${field}' korumalı alan`);
+            else if (!shape.conditionSlugs.has(field))
+                unknownFields.push(`${label}: '${field}' '${shape.slug}' entity'sinin koşulda kullanılabilir alanı değil`);
+        }
+        if (hasValue(grant.scope) && grant.scope !== 'all' && !shape.hasOwnerFields)
+            withoutOwner.push(`${label}: '${shape.slug}' entity'sinde sys_owner_user_id / sys_owner_unit_id yok (scope '${String(grant.scope)}')`);
+        if (isMaskGrant(grant)) {
+            const field = shape.fieldSlugById.get(String(grant.resourceKey).split(':')[2] ?? '');
+            if (field && !field.isProtected)
+                unprotectedMasks.push(`${shape.slug}.${field.slug}`);
+        }
+    }
+    return [
+        ...(protectedHits.length > 0 ? [{ ruleId: 'ACC-002', severity: 'block', message: `Koşul korumalı alana bakıyor — korumalı alanın ana kolonunda maske durur, koşul SQL'i düz değeri göremez; platform bu alanı koşul alanı saymaz (AccessConditionInvalidException / AccessConditionFieldProtected): ${protectedHits.join(' · ')}. Korumalı alanı sorgulanabilir kılmanın yolu türetilmiş alandır (derivedFromFieldId + derivationRule).`, guide: 'ngapps://guides/access' }] : []),
+        ...(unknownFields.length > 0 ? [{ ruleId: 'ACC-002', severity: 'warn', message: `Koşul alanı kaynak kataloğunda görünmüyor (gizli/sistem alanı ya da yanlış slug; platform 'unknown field' ile reddeder): ${unknownFields.join(' · ')}. Alanları access_resource_list { type: 'field' } ile görün.`, guide: 'ngapps://guides/access' }] : []),
+        ...(unprotectedMasks.length > 0 ? [{ ruleId: 'ACC-017', severity: 'warn', message: `field.read 'masked' korumasız alanda: ${unprotectedMasks.join(' · ')}. Maske alanın depolama korumasından gelir — alan entity_protection_update ile korunmadıysa politika 'masked' uygulayacak bir maske bulamaz; 38/M-3'te değer düz döndü, kabiliyet yine access: masked dedi ve işleçlerde contains/sıralama açık kaldı. Önce entity_protection_update { field, protection: { mode: 'masked', mask } } ile alanı koruyun ya da bu kullanıcıdan alanı gizlemek için fieldAccess: 'hidden' verin.`, guide: 'ngapps://guides/access' }] : []),
+        ...(withoutOwner.length > 0 ? [{ ruleId: 'ACC-003', severity: 'warn', message: `Sahiplik alanı olmayan entity'ye kapsam yazılıyor — platform 400 AccessScopeRequiresOwnerFields döner: ${withoutOwner.join(' · ')}. Kompleks projede yeni entity alanları kendiliğinden alır; eski entity için owner-fields işi (POST /{proje}/DataJobs/owner-fields/{datasourceId}) ya da scope: 'all' + koşul.`, guide: 'ngapps://guides/access' }] : [])
+    ];
+}
+/** Korumalı alanda platformun kabul ettiği işleçler (`FieldProtectionService`): eşitlik, üyelik, boşluk. */
+export const protectedFilterOperators = new Set(['eq', 'neq', 'in', 'notin', 'isnull', 'isnotnull']);
+function collectFilters(filters, into) {
+    for (const entry of asList(filters)) {
+        const filter = asObject(entry);
+        if (!filter)
+            continue;
+        if (typeof filter.field === 'string' && filter.field !== '')
+            into.push({ field: filter.field, operator: String(filter.operator ?? '') });
+        collectFilters(filter.children, into);
+    }
+}
+/**
+ * PROT-001 / PROT-002. Entity yalnız GEREKİRSE okunur: bütün filtreler korumalı alanda da geçerli
+ * bir işleçle yazılmışsa ve sıralama yoksa hiçbir tur atılmaz. Platform yalnız kök entity'nin
+ * alanını denetler (`slug` ya da `<entitySlug>.slug`, TB-24) — gateway aynı sınırı izler.
+ */
+export async function protectedFilterFindings(platform, resolver, entityRef, body) {
+    if (platform.config.policyMode === 'off')
+        return [];
+    const filters = [];
+    collectFilters(body.filters, filters);
+    const order = typeof body.order === 'string' && body.order.trim() !== '' ? body.order.trim() : undefined;
+    if (!order && filters.every(filter => protectedFilterOperators.has(filter.operator)))
+        return [];
+    const shape = await entityShape(resolver, entityRef);
+    if (!shape || shape.protectedSlugs.size === 0)
+        return [];
+    const local = (field) => field.startsWith(`${shape.slug}.`) ? field.slice(shape.slug.length + 1) : field;
+    const badFilters = filters.filter(filter => shape.protectedSlugs.has(local(filter.field)) && !protectedFilterOperators.has(filter.operator));
+    return [
+        ...(badFilters.length > 0 ? [{ ruleId: 'PROT-001', severity: 'block', message: `Korumalı alanda metin araması/karşılaştırma yapılamaz: ${badFilters.map(filter => `'${filter.field}' ${filter.operator}`).join(', ')}. Ana kolonda maske durur (şifreli modda değer hiç yoktur); platform 400 ProtectionOperatorNotAllowed döner. Geçerli işleçler: eq · neq · in · notin · isnull · isnotnull — şifreli modda eşitlik için alanın protection.exactSearch'ü açık olmalı. Kısmi arama gerekiyorsa türetilmiş alan (ör. telefon → operatör kodu) kurun.`, guide: 'ngapps://guides/access' }] : []),
+        ...(order && shape.protectedSlugs.has(local(order)) ? [{ ruleId: 'PROT-002', severity: 'block', message: `Korumalı alana göre sıralanamaz: '${order}' — sıra maskeye göre oluşurdu; platform 400 ProtectionSortNotAllowed döner. Başka bir alana ya da türetilmiş alana göre sıralayın.`, guide: 'ngapps://guides/access' }] : [])
+    ];
+}