@appaflytech/zeyrek-ai-mcp 0.0.5 → 0.0.7

package/dist/knowledge/backendConstraints.js

@@ -0,0 +1,982 @@
+import { schemaLimits } from './schemaGuard.js';
+export const EMPTY_GUID = '00000000-0000-0000-0000-000000000000';
+/** `ProjectConstants.SupportedLanguages` — ISO 639-1; proje dilleri ve çeviri anahtarları bu listeyle doğrulanır. */
+export const SUPPORTED_LANGUAGES = [
+    'aa', 'ab', 'ae', 'af', 'ak', 'am', 'an', 'ar', 'as', 'av', 'ay', 'az',
+    'ba', 'be', 'bg', 'bh', 'bi', 'bm', 'bn', 'bo', 'br', 'bs', 'ca', 'ce',
+    'ch', 'co', 'cr', 'cs', 'cu', 'cv', 'cy', 'da', 'de', 'dv', 'dz', 'ee',
+    'el', 'en', 'eo', 'es', 'et', 'eu', 'fa', 'ff', 'fi', 'fj', 'fo', 'fr',
+    'fy', 'ga', 'gd', 'gl', 'gn', 'gu', 'gv', 'ha', 'he', 'hi', 'ho', 'hr',
+    'ht', 'hu', 'hy', 'hz', 'ia', 'id', 'ie', 'ig', 'ii', 'ik', 'io', 'is',
+    'it', 'iu', 'ja', 'jv', 'ka', 'kg', 'ki', 'kj', 'kk', 'kl', 'km', 'kn',
+    'ko', 'kr', 'ks', 'ku', 'kv', 'kw', 'ky', 'la', 'lb', 'lg', 'li', 'ln',
+    'lo', 'lt', 'lu', 'lv', 'mg', 'mh', 'mi', 'mk', 'ml', 'mn', 'mr', 'ms',
+    'mt', 'my', 'na', 'nb', 'nd', 'ne', 'ng', 'nl', 'nn', 'no', 'nr', 'nv',
+    'ny', 'oc', 'oj', 'om', 'or', 'os', 'pa', 'pi', 'pl', 'ps', 'pt', 'qu',
+    'rm', 'rn', 'ro', 'ru', 'rw', 'sa', 'sc', 'sd', 'se', 'sg', 'si', 'sk',
+    'sl', 'sm', 'sn', 'so', 'sq', 'sr', 'ss', 'st', 'su', 'sv', 'sw', 'ta',
+    'te', 'tg', 'th', 'ti', 'tk', 'tl', 'tn', 'to', 'tr', 'ts', 'tt', 'tw',
+    'ty', 'ug', 'uk', 'ur', 'uz', 've', 'vi', 'vo', 'wa', 'wo', 'xh', 'yi',
+    'yo', 'za', 'zh', 'zu'
+];
+/** `StringExtensions.IsContainsSpecialChar` — adı doğru olmayan bir yardımcı: değer bu karakterlerin HİÇBİRİNİ içermiyorsa true döner. */
+export const FORBIDDEN_NAME_CHARACTERS = "\\|!#~$%&/=?»«@£§€{};'<>,";
+/** `ExternalComponentRules` (backend) — slug deseni tool'un kendisinde, paket boyutu da orada denetleniyor; burada kalanı. */
+export const EXTERNAL_COMPONENT_PROTOCOL_VERSION = 1;
+export const EXTERNAL_COMPONENT_PROP_TYPES = [
+    'text', 'long-text', 'switch', 'boolean', 'number', 'icon', 'link', 'image',
+    'color', 'date', 'datetime', 'time', 'file', 'flow', 'field', 'self',
+    'dropdown', 'switcher', 'radio', 'multi-select', 'object', 'object-form',
+    'array', 'views', 'component'
+];
+export const EXTERNAL_COMPONENT_RESERVED_PROPS = [
+    'attributes', 'children', 'class', 'classList', 'className', 'dataset', 'id',
+    'innerHTML', 'innerText', 'name', 'outerHTML', 'shadowRoot', 'slot', 'style',
+    'textContent'
+];
+const COMMON_FIELD_TYPES = ['text', 'number', 'bool', 'date', 'time', 'datetime', 'guid', 'float', 'relation', 'custom', 'object', 'array', 'file', 'incremental'];
+const DEFAULT_VALUE_TYPES = ['none', 'default-value', 'sql-expression'];
+const RELATION_TYPES = ['none', 'one-to-one', 'one-to-many', 'many-to-many'];
+const DTO_TYPES = ['object', 'array', 'bool', 'string', 'number', 'float', 'guid', 'date', 'time', 'datetime', 'file', 'anonymous'];
+const DTO_BEHAVIORS = ['primitive', 'object', 'array'];
+const QUERY_OUTPUT_TYPES = ['array', 'object'];
+const VIEW_PROVIDER_TYPES = ['postgres'];
+const MONGO_AUTHENTICATION_TYPES = ['none', 'password', 'ldap', 'kerberos', 'x.509'];
+/** `Query.RawQueryParameterPattern` birebir: `{{ name }}` ve `@name` (`::cast`, `@@`, e-posta ve string içi hariç). */
+const RAW_QUERY_PARAMETER_PATTERN = /\{\{\s*([A-Za-z_][A-Za-z0-9_]*)\s*\}\}|(?<![:@\w'])@([A-Za-z_][A-Za-z0-9_]*)/g;
+function asObjects(value) {
+    return (Array.isArray(value) ? value : []).filter((entry) => Boolean(entry) && typeof entry === 'object' && !Array.isArray(entry));
+}
+function asObject(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+}
+function hasText(value) {
+    return typeof value === 'string' && value.trim() !== '';
+}
+function isBlankValue(value) {
+    return value === undefined || value === null || (typeof value === 'string' && value.trim() === '');
+}
+function isEmptyGuid(value) {
+    return typeof value === 'string' && (value.trim() === '' || value === EMPTY_GUID);
+}
+function isPresent(value) {
+    return value !== undefined && value !== null;
+}
+/** FluentValidation `{PropertyName}` görünümü: `rawQuery` → `Raw Query`, `fieldIds` → `Field Ids`. */
+function displayName(path) {
+    const last = path.split('.').pop()?.replace(/\[\d*\]$/, '') ?? path;
+    return last.replace(/([a-z0-9])([A-Z])/g, '$1 $2').replace(/^./, first => first.toUpperCase());
+}
+function locate(node, segments, label, into) {
+    const head = segments[0];
+    if (head === undefined) {
+        into.push({ path: label, value: node });
+        return;
+    }
+    const rest = segments.slice(1);
+    const isArray = head.endsWith('[]');
+    const key = isArray ? head.slice(0, -2) : head;
+    const record = asObject(node);
+    // Üst düğüm yoksa kural susar — backend de `When(x is not null)` ile aynı şeyi yapar.
+    if (record === undefined)
+        return;
+    const value = record[key];
+    const childLabel = label === '' ? key : `${label}.${key}`;
+    if (!isArray) {
+        locate(value, rest, childLabel, into);
+        return;
+    }
+    if (!Array.isArray(value))
+        return;
+    value.forEach((entry, index) => locate(entry, rest, `${childLabel}[${index}]`, into));
+}
+function flattenFilters(filters) {
+    const flat = [];
+    const pending = [...asObjects(filters)];
+    while (pending.length > 0) {
+        const filter = pending.shift();
+        flat.push(filter);
+        pending.push(...asObjects(filter.children));
+    }
+    return flat;
+}
+/** `FilterType` enum'unun ilk değeri `single`; alan yazılmamışsa backend onu single okur. */
+function isSingleFilter(filter) {
+    return filter.filterType === undefined || filter.filterType === null || String(filter.filterType).toLowerCase() === 'single';
+}
+function flattenJoins(joins) {
+    const flat = [];
+    const pending = [...asObjects(joins)];
+    while (pending.length > 0) {
+        const join = pending.shift();
+        flat.push(join);
+        pending.push(...asObjects(join.joins));
+    }
+    return flat;
+}
+function duplicateKeys(values) {
+    const counts = new Map();
+    for (const value of values)
+        counts.set(value, (counts.get(value) ?? 0) + 1);
+    return [...counts.entries()].filter(([, count]) => count > 1).map(([value]) => value);
+}
+function outOfDictionary(label, value, dictionary) {
+    if (!isPresent(value))
+        return [];
+    return dictionary.includes(String(value))
+        ? []
+        : [`${label}: Please use a valid value for '${label}': ${dictionary.join(', ')}. Received: '${String(value)}'. — platform tanımadığı enum metnini 400 InvalidEnumTokenException ile reddeder (StringEnumConverter.ReadJson).`];
+}
+export function nameCharacterFindings(label, value) {
+    if (!hasText(value))
+        return [`${label}: '${displayName(label)}' must not be empty.`];
+    const found = [...FORBIDDEN_NAME_CHARACTERS].filter(character => value.includes(character));
+    return found.length === 0
+        ? []
+        : [`${label}: '${value}' şu karakterleri içeremez: ${found.map(character => `'${character}'`).join(' ')} — yasak küme \\|!#~$%&/=?»«@£§€{};'<>, (StringExtensions.IsContainsSpecialChar). Platform 422 döner.`];
+}
+/**
+ * Tek satır sözlüğünün backend kuralı (Create/Update/Bulk `Row` validator'ları): boş olamaz,
+ * boş anahtar taşıyamaz, bütün değerleri null olamaz. `UpdateRowCommand` id'yi de satırda arar
+ * ama bu doğrulayıcı değil handler işidir; burada yalnız validator aynası var.
+ */
+export function rowShapeFindings(label, row) {
+    const record = asObject(row);
+    if (record === undefined || Object.keys(record).length === 0) {
+        return [`${label}: '${displayName(label)}' must not be empty. — satır sözlüğü boş; alan SLUG'ı → değer çiftleri verin.`];
+    }
+    const findings = [];
+    const blankKeys = Object.keys(record).filter(key => key.trim() === '');
+    if (blankKeys.length > 0)
+        findings.push(`${label}: boş (whitespace) anahtar var — her anahtar bir alan slug'ı olmalı.`);
+    if (Object.values(record).every(value => value === null || value === undefined)) {
+        findings.push(`${label}: bütün değerler null — en az bir alana değer yazılmalı (backend: !Values.All(null)).`);
+    }
+    return findings;
+}
+export const fieldLimits = [
+    { ruleId: 'ENT-015', command: 'CreateEntityCommand', path: 'name', required: true, maxLength: 255, sourceRef: 'CreateEntityCommandValidator: RuleFor(Name).NotEmpty().MaximumLength(255)' },
+    { ruleId: 'ENT-015', command: 'CreateEntityCommand', path: 'description', maxLength: 1024, sourceRef: 'CreateEntityCommandValidator: RuleFor(Description).MaximumLength(1024)' },
+    { ruleId: 'ENT-015', command: 'CreateEntityCommand', path: 'slug', required: true, sourceRef: 'CreateEntityCommandValidator: RuleFor(Slug).NotEmpty()' },
+    { ruleId: 'ENT-015', command: 'CreateEntityCommand', path: 'fields[].name', maxLength: 50, sourceRef: 'FieldDtoValidator: RuleFor(Name).MaximumLength(50)' },
+    { ruleId: 'ENT-015', command: 'CreateEntityCommand', path: 'fields[].description', maxLength: 512, sourceRef: 'FieldDtoValidator: RuleFor(Description).MaximumLength(512)' },
+    { ruleId: 'ENT-015', command: 'CreateEntityCommand', path: 'fields[].slug', required: true, sourceRef: 'FieldDtoValidator: RuleFor(Slug).NotEmpty()' },
+    { ruleId: 'ENT-015', command: 'CreateEntityCommand', path: 'fields[].dbType', required: true, maxLength: 50, sourceRef: 'FieldDtoValidator: RuleFor(DbType).NotEmpty().MaximumLength(50)' },
+    { ruleId: 'ENT-015', command: 'UpdateEntityCommand', path: 'name', required: true, maxLength: 255, sourceRef: 'UpdateEntityCommandValidator: RuleFor(Name).NotEmpty().MaximumLength(255)' },
+    { ruleId: 'ENT-015', command: 'UpdateEntityCommand', path: 'description', maxLength: 1024, sourceRef: 'UpdateEntityCommandValidator: RuleFor(Description).MaximumLength(1024)' },
+    { ruleId: 'ENT-015', command: 'UpdateEntityCommand', path: 'fields[].name', maxLength: 50, sourceRef: 'FieldDtoValidator: RuleFor(Name).MaximumLength(50)' },
+    { ruleId: 'ENT-015', command: 'UpdateEntityCommand', path: 'fields[].description', maxLength: 512, sourceRef: 'FieldDtoValidator: RuleFor(Description).MaximumLength(512)' },
+    { ruleId: 'ENT-015', command: 'UpdateEntityCommand', path: 'fields[].slug', required: true, sourceRef: 'FieldDtoValidator: RuleFor(Slug).NotEmpty()' },
+    { ruleId: 'ENT-015', command: 'UpdateEntityCommand', path: 'fields[].dbType', required: true, maxLength: 50, sourceRef: 'FieldDtoValidator: RuleFor(DbType).NotEmpty().MaximumLength(50)' },
+    { ruleId: 'MS-017', command: 'CreateMicroserviceCommand', path: 'name', required: true, sourceRef: 'CreateMicroserviceCommandValidator: RuleFor(Name).NotEmpty()' },
+    { ruleId: 'MS-017', command: 'CreateMicroserviceCommand', path: 'url', required: true, sourceRef: 'CreateMicroserviceCommandValidator: RuleFor(Url).NotEmpty()' },
+    { ruleId: 'MS-017', command: 'UpdateMicroserviceCommand', path: 'name', required: true, sourceRef: 'UpdateMicroserviceCommandValidator: RuleFor(Name).NotEmpty()' },
+    { ruleId: 'MS-017', command: 'UpdateMicroserviceCommand', path: 'slug', required: true, sourceRef: 'UpdateMicroserviceCommandValidator: RuleFor(Slug).NotEmpty()' },
+    { ruleId: 'MS-017', command: 'UpdateMicroserviceCommand', path: 'url', required: true, sourceRef: 'UpdateMicroserviceCommandValidator: RuleFor(Url).NotEmpty()' },
+    { ruleId: 'WF-026', command: 'CreateWorkflowCommand', path: 'name', required: true, sourceRef: 'CreateWorkflowCommandValidator: RuleFor(Name).NotEmpty()' },
+    { ruleId: 'WF-026', command: 'CreateWorkflowCommand', path: 'slug', required: true, sourceRef: 'CreateWorkflowCommandValidator: RuleFor(Slug).NotEmpty()' },
+    { ruleId: 'WF-026', command: 'UpdateWorkflowCommand', path: 'name', required: true, sourceRef: 'UpdateWorkflowCommandValidator: RuleFor(Name).NotEmpty()' },
+    { ruleId: 'WF-026', command: 'UpdateWorkflowCommand', path: 'slug', required: true, sourceRef: 'UpdateWorkflowCommandValidator: RuleFor(Slug).NotEmpty()' },
+    { ruleId: 'WF-026', command: 'PreviewWorkflowCommand', path: 'name', required: true, sourceRef: 'PreviewWorkflowCommandValidator: RuleFor(Name).NotEmpty()' },
+    { ruleId: 'WF-026', command: 'PreviewWorkflowCommand', path: 'slug', required: true, sourceRef: 'PreviewWorkflowCommandValidator: RuleFor(Slug).NotEmpty()' },
+    { ruleId: 'QRY-001', command: 'CreateQueryCommand', path: 'slug', required: true, sourceRef: 'CreateQueryCommandValidator: RuleFor(Slug).NotEmpty()' },
+    { ruleId: 'QRY-001', command: 'CreateQueryCommand', path: 'rawQuery', required: true, sourceRef: 'CreateQueryCommandValidator: RuleFor(RawQuery).NotEmpty()' },
+    { ruleId: 'QRY-001', command: 'CreateQueryCommand', path: 'datasourceId', required: true, guid: true, sourceRef: 'CreateQueryCommandValidator: RuleFor(DatasourceId).NotEmpty().NotEqual(Guid.Empty)' },
+    { ruleId: 'QRY-001', command: 'UpdateQueryCommand', path: 'slug', required: true, sourceRef: 'UpdateQueryCommandValidator: RuleFor(Slug).NotEmpty()' },
+    { ruleId: 'QRY-001', command: 'UpdateQueryCommand', path: 'rawQuery', required: true, sourceRef: 'UpdateQueryCommandValidator: RuleFor(RawQuery).NotEmpty()' },
+    { ruleId: 'QRY-001', command: 'UpdateQueryCommand', path: 'datasourceId', required: true, guid: true, sourceRef: 'UpdateQueryCommandValidator: RuleFor(DatasourceId).NotEmpty().NotEqual(Guid.Empty)' },
+    { ruleId: 'QRY-001', command: 'PreviewQueryCommand', path: 'rawQuery', required: true, sourceRef: 'PreviewQueryCommandValidator: RuleFor(RawQuery).NotEmpty()' },
+    { ruleId: 'QRY-001', command: 'PreviewQueryCommand', path: 'parameters[].name', required: true, sourceRef: 'PreviewQueryCommandValidator: RuleForEach(Parameters).ChildRules(Name.NotEmpty())' },
+    { ruleId: 'VIEW-001', command: 'CreateViewCommand', path: 'name', required: true, sourceRef: 'CreateViewCommandValidator: RuleFor(Name).NotEmpty()' },
+    { ruleId: 'VIEW-001', command: 'UpdateViewCommand', path: 'name', required: true, sourceRef: 'UpdateViewCommandValidator: RuleFor(Name).NotEmpty()' },
+    { ruleId: 'DTO-001', command: 'CreateDataTransferObjectCommand', path: 'name', required: true, sourceRef: 'CreateDataTransferObjectCommandValidator: RuleFor(Name).NotEmpty()' },
+    { ruleId: 'DTO-001', command: 'CreateDataTransferObjectCommand', path: 'slug', required: true, sourceRef: 'CreateDataTransferObjectCommandValidator: RuleFor(Slug).NotEmpty()' },
+    { ruleId: 'DTO-001', command: 'UpdateDataTransferObjectCommand', path: 'name', required: true, sourceRef: 'UpdateDataTransferObjectCommandValidator: RuleFor(Name).NotEmpty()' },
+    { ruleId: 'DTO-001', command: 'UpdateDataTransferObjectCommand', path: 'slug', required: true, sourceRef: 'UpdateDataTransferObjectCommandValidator: RuleFor(Slug).NotEmpty()' },
+    { ruleId: 'DS-001', command: 'CreateDatasourceCommand', path: 'name', required: true, maxLength: 50, sourceRef: 'CreateDatasourceCommandValidator: RuleFor(Name).NotNull().NotEmpty().MaximumLength(50)' },
+    { ruleId: 'DS-001', command: 'CreateDatasourceCommand', path: 'description', maxLength: 255, sourceRef: 'CreateDatasourceCommandValidator: RuleFor(Description).MaximumLength(255)' },
+    { ruleId: 'DS-001', command: 'CreateDatasourceCommand', path: 'dbName', required: true, maxLength: 63, sourceRef: 'CreateDatasourceCommandValidator: RuleFor(DbName).NotNull().NotEmpty().MaximumLength(63)' },
+    { ruleId: 'DS-001', command: 'CreateDatasourceCommand', path: 'host', required: true, maxLength: 255, sourceRef: 'CreateDatasourceCommandValidator: RuleFor(Host).NotNull().NotEmpty().MaximumLength(255)' },
+    { ruleId: 'DS-001', command: 'CreateDatasourceCommand', path: 'port', range: [0, 65535], sourceRef: 'CreateDatasourceCommandValidator: RuleFor(Port).Must(0 ≤ p ≤ 65535)' },
+    { ruleId: 'DS-001', command: 'UpdateDatasourceCommand', path: 'name', required: true, maxLength: 50, sourceRef: 'UpdateDatasourceCommandValidator: RuleFor(Name).NotNull().NotEmpty().MaximumLength(50)' },
+    { ruleId: 'DS-001', command: 'UpdateDatasourceCommand', path: 'description', maxLength: 255, sourceRef: 'UpdateDatasourceCommandValidator: RuleFor(Description).MaximumLength(255)' },
+    { ruleId: 'DS-001', command: 'UpdateDatasourceCommand', path: 'dbName', required: true, maxLength: 63, sourceRef: 'UpdateDatasourceCommandValidator: RuleFor(DbName).NotNull().NotEmpty().MaximumLength(63)' },
+    { ruleId: 'DS-001', command: 'UpdateDatasourceCommand', path: 'host', required: true, maxLength: 255, sourceRef: 'UpdateDatasourceCommandValidator: RuleFor(Host).NotNull().NotEmpty().MaximumLength(255)' },
+    { ruleId: 'DS-001', command: 'UpdateDatasourceCommand', path: 'port', range: [0, 65535], sourceRef: 'UpdateDatasourceCommandValidator: RuleFor(Port).Must(0 ≤ p ≤ 65535)' },
+    { ruleId: 'FLD-001', command: 'CreateFolderCommand', path: 'name', required: true, sourceRef: 'CreateFolderCommandValidator: RuleFor(Name).NotEmpty().Must(IsContainsSpecialChar)' }
+];
+function limitMessages(limit, located) {
+    const { path, value } = located;
+    const label = displayName(path);
+    const messages = [];
+    const empty = isBlankValue(value) || (Array.isArray(value) && value.length === 0) || (limit.guid === true && isEmptyGuid(value));
+    if (limit.required && empty) {
+        messages.push(`${path}: '${label}' must not be empty.`);
+        return messages;
+    }
+    if (typeof value === 'string') {
+        if (limit.maxLength !== undefined && value.length > limit.maxLength) {
+            messages.push(`${path}: The length of '${label}' must be ${limit.maxLength} characters or fewer. You entered ${value.length} characters. (${value.length - limit.maxLength} karakter fazla)`);
+        }
+        if (limit.minLength !== undefined && value.length < limit.minLength) {
+            messages.push(`${path}: The length of '${label}' must be at least ${limit.minLength} characters. You entered ${value.length} characters.`);
+        }
+        if (limit.pattern !== undefined && value !== '') {
+            try {
+                if (!new RegExp(limit.pattern).test(value))
+                    messages.push(`${path}: '${label}' is not in the correct format. — beklenen desen: ${limit.pattern}`);
+            }
+            catch {
+                // .NET'e özgü bir desen JS'te derlenmezse denetim atlanır; karar platforma kalır.
+            }
+        }
+    }
+    if (typeof value === 'number' && limit.range !== undefined && (value < limit.range[0] || value > limit.range[1])) {
+        messages.push(`${path}: '${label}' must be between ${limit.range[0]} and ${limit.range[1]}. You entered ${value}.`);
+    }
+    if (Array.isArray(value) && limit.minItems !== undefined && value.length < limit.minItems) {
+        messages.push(`${path}: '${label}' must contain at least ${limit.minItems} item(s). You entered ${value.length}.`);
+    }
+    return messages;
+}
+/**
+ * Önlem: `EntityIndexDtoValidator` ad uzunluğunu ÖNEK HARİÇ ölçer (`NameWithoutGeneratedPrefix`,
+ * `OverridePropertyName(Name)`). MicroElements 6.1.0 bu kuralı `name`'e YAZMIYOR (ölçüldü
+ * 2026-09-08: EntityIndexDto.name yalnız minLength 1) — bir sürüm yazarsa gidiş-dönüşte
+ * `IX_<5 hane>_` öneki taşıyan 41 karakterlik ad yanlış bloklanır. Öneki düşerek ölçen ENT-013
+ * doğru kuraldır; şemanın o satırı her hâlükârda atlanır.
+ */
+const ignoredSchemaLimits = [
+    { command: /EntityCommand$/, path: 'indexes[].name', kind: 'maxLength' }
+];
+const bulkRowCommands = ['CreateBulkRowCommand', 'UpdateBulkRowCommand'];
+function ownerRuleId(command) {
+    if (bulkRowCommands.includes(command))
+        return 'ROW-002';
+    return backendRules.find(rule => Object.values(rule.commands).includes(command))?.id;
+}
+function fromSchema(command, limit, ruleId) {
+    const range = limit.minimum !== undefined || limit.maximum !== undefined
+        ? [limit.minimum ?? Number.NEGATIVE_INFINITY, limit.maximum ?? Number.POSITIVE_INFINITY]
+        : undefined;
+    return {
+        ruleId,
+        command,
+        path: limit.path,
+        ...(limit.required ? { required: true } : {}),
+        ...(limit.maxLength !== undefined ? { maxLength: limit.maxLength } : {}),
+        ...(limit.minLength !== undefined ? { minLength: limit.minLength } : {}),
+        ...(range !== undefined ? { range } : {}),
+        ...(limit.pattern !== undefined ? { pattern: limit.pattern } : {}),
+        ...(limit.minItems !== undefined ? { minItems: limit.minItems } : {}),
+        sourceRef: `ngapps://schemas/${command} (swagger ← FluentValidation)`
+    };
+}
+/**
+ * Bir komutun geçerli sınır listesi: paketlenmiş swagger şemasındaki kısıtlar (backend'in kendi
+ * doğrulayıcısından aktığı için birincil) + el yazımı katalog (şemada olmayan yolu tamamlar; aynı
+ * yolda şema kazanır). Şema yenilenmemişse liste yalnız katalogtan oluşur — iki kaynak aynı ihlali
+ * iki kez raporlamaz.
+ */
+export function effectiveLimits(command) {
+    const owner = ownerRuleId(command) ?? 'SCHEMA';
+    const merged = new Map();
+    for (const limit of schemaLimits(command)) {
+        const ignored = ignoredSchemaLimits.some(entry => entry.command.test(command) && entry.path === limit.path);
+        const kept = ignored ? Object.fromEntries(Object.entries(limit).filter(([key]) => !ignoredSchemaLimits.some(entry => entry.command.test(command) && entry.path === limit.path && entry.kind === key))) : limit;
+        if (Object.keys(kept).length > 1)
+            merged.set(kept.path, fromSchema(command, kept, owner));
+    }
+    for (const catalog of fieldLimits.filter(entry => entry.command === command)) {
+        const existing = merged.get(catalog.path);
+        if (existing === undefined) {
+            merged.set(catalog.path, catalog);
+            continue;
+        }
+        merged.set(catalog.path, {
+            ...existing,
+            ruleId: catalog.ruleId,
+            ...(existing.required === undefined && catalog.required ? { required: true } : {}),
+            ...(catalog.guid ? { guid: true } : {}),
+            ...(existing.maxLength === undefined && catalog.maxLength !== undefined ? { maxLength: catalog.maxLength } : {}),
+            ...(existing.minLength === undefined && catalog.minLength !== undefined ? { minLength: catalog.minLength } : {}),
+            ...(existing.range === undefined && catalog.range !== undefined ? { range: catalog.range } : {}),
+            sourceRef: `${existing.sourceRef} · ${catalog.sourceRef}`
+        });
+    }
+    return [...merged.values()];
+}
+/**
+ * Bir komutun bütün uzunluk/zorunluluk sınırlarını gövdeye uygular; mesajlar FluentValidation'ın
+ * İngilizce cümleleridir (ajan 422'de aynısını görürdü). `ruleId` verilirse yalnız o kurala bağlı
+ * sınırlar koşar — aynı komutu paylaşan kurallar (ENT-015…018) aynı ihlali dört kez raporlamasın.
+ */
+export function limitFindings(command, body, ruleId) {
+    const findings = [];
+    for (const limit of effectiveLimits(command).filter(entry => ruleId === undefined || entry.ruleId === ruleId)) {
+        const located = [];
+        locate(body, limit.path.split('.'), '', located);
+        for (const entry of located)
+            findings.push(...limitMessages(limit, entry));
+    }
+    return findings;
+}
+function entityFieldSetFindings(body, operation) {
+    const fields = asObjects(body.fields);
+    if (!Array.isArray(body.fields))
+        return [];
+    const findings = [];
+    const primaryKeys = fields.filter(field => field.primaryKey === true);
+    if (primaryKeys.length !== 1) {
+        findings.push(`fields: Please select exactly one primary key. — primaryKey:true olan alan sayısı ${primaryKeys.length}; tam 1 olmalı. Kalıp: { slug:'id', name:'Id', dbType:'UUID', commonType:'guid', primaryKey:true, unique:true, identity:true, nullable:false, properties:{ generationType: 0 } }.`);
+    }
+    // Create yolu adı `name` üzerinden, update yolu `slug` üzerinden tekil arar. Create'te `name`
+    // yazılmayan iki alan aynı (boş) gruba düşer ve 422 "Duplicate value 'Slug'" gelir — mesaj
+    // slug'ı suçlar, sebep ad eksikliğidir.
+    const keyField = operation === 'create' ? 'name' : 'slug';
+    const keys = fields.map(field => (typeof field[keyField] === 'string' ? field[keyField] : '').toLowerCase());
+    const duplicates = duplicateKeys(keys);
+    if (duplicates.length > 0) {
+        const shown = duplicates.map(key => key === '' ? `(${keyField} yazılmamış)` : `'${key}'`).join(', ');
+        findings.push(`fields: Duplicate value: 'Slug'. — ${operation === 'create' ? "create yolu alanları 'name' üzerinden" : "update yolu alanları 'slug' üzerinden"} büyük/küçük harf duyarsız tekil ister; çakışan: ${shown}.${operation === 'create' && duplicates.includes('') ? " Create'te her alana 'name' yazın; name'siz iki alan aynı boş gruba düşer ve platformun mesajı slug'ı suçlar." : ''}`);
+    }
+    return findings;
+}
+function entityFieldFlagFindings(body) {
+    const findings = [];
+    asObjects(body.fields).forEach((field, index) => {
+        const label = `fields[${index}]${hasText(field.slug) ? ` ('${field.slug}')` : ''}`;
+        const commonType = isPresent(field.commonType) ? String(field.commonType) : 'text';
+        findings.push(...outOfDictionary(`${label}.commonType`, field.commonType, COMMON_FIELD_TYPES));
+        findings.push(...outOfDictionary(`${label}.defaultValueType`, field.defaultValueType, DEFAULT_VALUE_TYPES));
+        findings.push(...outOfDictionary(`${label}.relationType`, field.relationType, RELATION_TYPES));
+        if (field.primaryKey === true) {
+            if (field.nullable === true)
+                findings.push(`${label}: primaryKey:true olan alan nullable:true olamaz ('Nullable' must be equal to 'False').`);
+            if (field.hidden === true)
+                findings.push(`${label}: primaryKey:true olan alan hidden:true olamaz ('Hidden' must be equal to 'False').`);
+        }
+        if (field.identity === true && field.nullable === true) {
+            findings.push(`${label}: identity:true olan alan nullable:true olamaz ('Nullable' must be equal to 'False').`);
+        }
+        if (field.isLocalized === true) {
+            const offending = ['primaryKey', 'identity', 'unique'].filter(flag => field[flag] === true);
+            if (offending.length > 0)
+                findings.push(`${label}: isLocalized:true olan alan ${offending.join('/')} taşıyamaz — çeviri satırı yan entity'de tutulur, kısıt oraya gider.`);
+            if (isPresent(field.relationType) && String(field.relationType).toLowerCase() !== 'none') {
+                findings.push(`${label}: isLocalized:true olan alan ilişki olamaz (relationType 'none' olmalı).`);
+            }
+        }
+        if (isPresent(field.folderId) && !isEmptyGuid(field.folderId) && commonType !== 'file') {
+            findings.push(`${label}: folderId yalnız commonType:'file' alanında verilir ('Folder Id' must be empty); bu alan '${commonType}'.`);
+        }
+        const properties = asObject(field.properties);
+        const hasGenerationType = properties !== undefined && Object.keys(properties).some(key => key.toLowerCase() === 'generationtype');
+        if (hasGenerationType && commonType !== 'guid' && commonType !== 'number') {
+            findings.push(`${label}: properties.generationType yalnız commonType 'guid' ya da 'number' alanında geçerli; bu alan '${commonType}'. Otomatik üretim istemiyorsanız anahtarı kaldırın.`);
+        }
+    });
+    return findings;
+}
+function entityTransferFindings(body) {
+    const findings = [];
+    const mode = isPresent(body.recordTransferMode) ? String(body.recordTransferMode).toLowerCase() : undefined;
+    const ids = Array.isArray(body.transferRowIds) ? body.transferRowIds : undefined;
+    if (mode !== undefined && !['all', 'specific'].includes(mode)) {
+        findings.push(...outOfDictionary('recordTransferMode', body.recordTransferMode, ['all', 'specific']));
+    }
+    if (mode === 'specific' && (ids === undefined || ids.length === 0)) {
+        findings.push("transferRowIds: Transfer records are required. — recordTransferMode 'specific' iken taşınacak satır id listesi boş olamaz.");
+    }
+    if (ids !== undefined) {
+        const strings = ids.map(id => typeof id === 'string' ? id : String(id ?? ''));
+        const duplicates = duplicateKeys(strings);
+        if (duplicates.length > 0)
+            findings.push(`transferRowIds: Duplicate value: 'Transfer Row Id' — tekrar eden: ${duplicates.join(', ')}.`);
+        if (strings.some(id => id.trim() === ''))
+            findings.push("transferRowIds: 'Transfer Row Ids' must not be empty. — boş id var.");
+    }
+    return findings;
+}
+function guidReferenceFindings(body, keys) {
+    return keys
+        .filter(key => isPresent(body[key]) && isEmptyGuid(body[key]))
+        .map(key => `${key}: '${displayName(key)}' must not be empty / must not be equal to '${EMPTY_GUID}'. — alan verilecekse gerçek bir GUID olmalı; vermeyecekseniz anahtarı hiç yazmayın.`);
+}
+function microserviceFindings(body) {
+    const findings = guidReferenceFindings(body, ['queryId', 'entityId', 'workflowId']);
+    const parameters = asObject(body.sourceParameters);
+    if (parameters === undefined)
+        return findings;
+    const operation = isPresent(parameters.operation) ? String(parameters.operation).toLowerCase() : undefined;
+    asObjects(parameters.fields).forEach((field, index) => {
+        if (String(field.source ?? '').toLowerCase() === 'expression' && isBlankValue(field.value)) {
+            findings.push(`sourceParameters.fields[${index}]: source:'expression' olan alanın 'value' ifadesi boş — ifade kaynağı değer ister (CreateMicroserviceCommandValidator: Fields.Where(Expression).Must(Value dolu)).`);
+        }
+        if (body.source === 'table' && operation !== 'upsert' && isPresent(field.writeOn) && String(field.writeOn).toLowerCase() !== 'always') {
+            findings.push(`sourceParameters.fields[${index}]: writeOn:'${String(field.writeOn)}' yalnız operation:'upsert' ucunda anlamlı; bu uç '${operation ?? '?'}' — writeOn'u kaldırın ya da 'always' bırakın (Fields.All(WriteOn == Always) when Operation != Upsert).`);
+        }
+    });
+    flattenFilters(parameters.filters).forEach((filter, index) => {
+        if (!isSingleFilter(filter))
+            return;
+        if (String(filter.source ?? '').toLowerCase() === 'expression' && isBlankValue(filter.value)) {
+            findings.push(`sourceParameters.filters (düz sıra ${index}): source:'expression' olan filtrenin 'value' ifadesi boş — ifade kaynağı değer ister.`);
+        }
+        if (isBlankValue(filter.fieldId) || isEmptyGuid(filter.fieldId)) {
+            findings.push(`sourceParameters.filters (düz sıra ${index}): tekil filtrede 'fieldId' zorunlu ve gerçek bir alan GUID'i olmalı (Filters.Where(Single).All(FieldId dolu)); alan id'lerini entity_get view:'outline' ile okuyun.`);
+        }
+    });
+    if (body.source === 'table') {
+        flattenJoins(parameters.joins).forEach((join, index) => {
+            const missing = ['entityId', 'fieldId'].filter(key => isBlankValue(join[key]) || isEmptyGuid(join[key]));
+            if (missing.length > 0)
+                findings.push(`sourceParameters.joins (düz sıra ${index}): ${missing.join(' ve ')} boş — join tanımı eksik (TableSourceJoinIncomplete, 422). Alias kuralı MS-005'te.`);
+        });
+    }
+    return findings;
+}
+function workflowFindings(body, operation) {
+    const findings = [];
+    const type = String(body.type ?? '').toLowerCase();
+    for (const [dtoKey, behaviorKey] of [['returnDtoId', 'returnBehavior'], ['parameterDtoId', 'parameterBehavior']]) {
+        if (isPresent(body[dtoKey])) {
+            if (isEmptyGuid(body[dtoKey]))
+                findings.push(`${dtoKey}: '${displayName(dtoKey)}' must not be equal to '${EMPTY_GUID}'.`);
+            if (isBlankValue(body[behaviorKey]))
+                findings.push(`${behaviorKey}: '${displayName(behaviorKey)}' must not be empty. — ${dtoKey} verilen yerde ${behaviorKey} da zorunlu: primitive | object | array.`);
+            else
+                findings.push(...outOfDictionary(behaviorKey, body[behaviorKey], DTO_BEHAVIORS));
+        }
+        else if (operation !== 'create' && isPresent(body[behaviorKey])) {
+            findings.push(`${behaviorKey}: '${displayName(behaviorKey)}' must be empty. — ${dtoKey} yokken ${behaviorKey} null olmalı (Update/Preview doğrulayıcısı).`);
+        }
+    }
+    if (operation !== 'create' && type === 'workflow' && !isPresent(body.parameterDtoId) && isPresent(body.previewPayload)) {
+        findings.push("previewPayload: Preview payload requires a parameter DTO. — type:'workflow' akışta parameterDtoId yokken previewPayload verilemez; girdi DTO'sunu bağlayın ya da alanı kaldırın (PreviewPayloadRequiresParameterDto).");
+    }
+    if (operation !== 'preview') {
+        asObjects(body.steps).forEach((step, index) => {
+            const rule = asObject(step.rule);
+            const stepLabel = `steps[${index}]${hasText(step.name) ? ` ('${step.name}')` : ''}`;
+            if (String(step.type ?? '').toLowerCase() === 'variable' && rule !== undefined && String(rule.name ?? '').toLowerCase() === 'user') {
+                findings.push(`${stepLabel}: 'user' adı variable adımına verilemez — set-user adımına ayrılmıştır (Steps.Must(!Variable && Name == "user")). Başka bir ad seçin ya da set-user kullanın.`);
+            }
+            if (rule !== undefined) {
+                flattenFilters(rule.filters).forEach((filter, filterIndex) => {
+                    if (isSingleFilter(filter) && (isBlankValue(filter.fieldId) || isEmptyGuid(filter.fieldId))) {
+                        findings.push(`${stepLabel}.rule.filters (düz sıra ${filterIndex}): tekil filtrede 'fieldId' zorunlu ve gerçek bir GUID olmalı; alan id'lerini entity_get view:'outline' ile okuyun.`);
+                    }
+                });
+            }
+        });
+        if (type === 'automation') {
+            if (isPresent(body.parameterDtoId))
+                findings.push("parameterDtoId: 'Parameter Dto Id' must be empty. — automation girdi DTO'su almaz; olayı tetikleyen satır girdidir.");
+            const automation = asObject(body.automation);
+            if (automation !== undefined && automation.isQueue === true) {
+                const order = automation.queueOrder;
+                if (typeof order !== 'number' || Number.isNaN(order))
+                    findings.push("automation.queueOrder: 'Queue Order' must not be empty. — isQueue:true iken queueOrder (0 ya da pozitif tam sayı) zorunlu.");
+                else if (order < 0)
+                    findings.push(`automation.queueOrder: 'Queue Order' must be greater than or equal to '0'. You entered ${order}.`);
+            }
+        }
+    }
+    return findings;
+}
+export function rawQueryParameterNames(rawQuery) {
+    if (typeof rawQuery !== 'string')
+        return [];
+    const names = new Map();
+    for (const match of rawQuery.matchAll(RAW_QUERY_PARAMETER_PATTERN)) {
+        const name = match[1] ?? match[2];
+        if (name !== undefined && !names.has(name.toLowerCase()))
+            names.set(name.toLowerCase(), name);
+    }
+    return [...names.values()];
+}
+function queryFindings(body, operation) {
+    const findings = outOfDictionary('outputType', body.outputType, QUERY_OUTPUT_TYPES);
+    if (operation !== 'create' || !hasText(body.rawQuery))
+        return findings;
+    const declared = new Set(asObjects(body.parameters).map(parameter => String(parameter.name ?? '').toLowerCase()));
+    const missing = rawQueryParameterNames(body.rawQuery).filter(name => !declared.has(name.toLowerCase()));
+    if (missing.length > 0) {
+        findings.push(`parameters: Query parameters are missing: ${missing.map(name => `'${name}'`).join(', ')}. — rawQuery'deki her @ad / {{ad}} 'parameters' listesinde { name, type } ile bildirilmeli (yalnız create yolu denetler; update sessiz geçer, çalışma anında düşer).`);
+    }
+    return findings;
+}
+function viewFindings(body) {
+    return outOfDictionary('providerType', body.providerType, VIEW_PROVIDER_TYPES);
+}
+function dtoChildrenFindings(children, label, findings) {
+    if (!Array.isArray(children))
+        return;
+    const nodes = asObjects(children);
+    const duplicates = duplicateKeys(nodes.map(child => String(child.slug ?? '').toLowerCase()).filter(slug => slug !== ''));
+    if (duplicates.length > 0)
+        findings.push(`${label}: Duplicate value: 'Slug' — kardeş alanlar arasında tekrar eden: ${duplicates.join(', ')} (büyük/küçük harf duyarsız).`);
+    nodes.forEach((child, index) => {
+        const childLabel = `${label}[${index}]${hasText(child.slug) ? ` ('${child.slug}')` : ''}`;
+        if (!hasText(child.slug))
+            findings.push(`${childLabel}: çocuk alanın 'slug'ı zorunlu (DataTransferObjectChildSlugRequired).`);
+        findings.push(...outOfDictionary(`${childLabel}.type`, child.type, DTO_TYPES));
+        if (isPresent(child.referenceId) && !['object', 'array'].includes(String(child.type ?? '').toLowerCase())) {
+            findings.push(`${childLabel}: referenceId (başka bir DTO'ya bağ) yalnız type 'object' ya da 'array' ile verilir; bu alan '${String(child.type ?? '?')}'.`);
+        }
+        dtoChildrenFindings(child.children, `${childLabel}.children`, findings);
+    });
+}
+function dtoFindings(body) {
+    const findings = outOfDictionary('type', body.type, DTO_TYPES);
+    dtoChildrenFindings(body.children, 'children', findings);
+    return findings;
+}
+function rowFindings(body) {
+    if (Array.isArray(body.rows)) {
+        return body.rows.flatMap((row, index) => rowShapeFindings(`rows[${index}]`, row));
+    }
+    return rowShapeFindings('row', body.row);
+}
+function datasourceFindings(body) {
+    const type = String(body.type ?? '').toLowerCase();
+    const properties = asObject(body.properties) ?? {};
+    const findings = [];
+    if (type === 'postgresql') {
+        for (const [key, max] of [['initialDatabase', 63], ['userName', 63], ['password', 1024]]) {
+            if (!hasText(properties[key]))
+                findings.push(`properties.${key}: '${displayName(key)}' must not be empty. — postgresql datasource'unda zorunlu (PostgreSqlPropertyValidator).`);
+            else if (properties[key].length > max)
+                findings.push(`properties.${key}: The length of '${displayName(key)}' must be ${max} characters or fewer. You entered ${properties[key].length} characters.`);
+        }
+    }
+    if (type === 'mongodb') {
+        const authenticationType = isPresent(properties.authenticationType) ? String(properties.authenticationType) : undefined;
+        findings.push(...outOfDictionary('properties.authenticationType', authenticationType, MONGO_AUTHENTICATION_TYPES));
+        if (authenticationType === 'password') {
+            for (const [key, max] of [['authenticationDatabase', 63], ['userName', 63], ['password', 1024]]) {
+                if (!hasText(properties[key]))
+                    findings.push(`properties.${key}: '${displayName(key)}' must not be empty. — mongodb + authenticationType 'password' iken zorunlu (MongoDbPropertyValidator).`);
+                else if (properties[key].length > max)
+                    findings.push(`properties.${key}: The length of '${displayName(key)}' must be ${max} characters or fewer. You entered ${properties[key].length} characters.`);
+            }
+        }
+    }
+    return findings;
+}
+const MICROFUNCTION_ENTRYPOINT_PATTERN = /^[A-Za-z_][\w./-]*\.[A-Za-z_]\w*$/;
+const MICROFUNCTION_ENVIRONMENT_KEY_PATTERN = /^[A-Z_][A-Z0-9_]*$/;
+const MICROFUNCTION_ROLE_ARN_PATTERN = /^arn:aws:iam::\d{12}:role\/.+$/;
+/**
+ * `MicrofunctionOptions.Limits` ile de sınırlanır (kök `.env`); buradaki değerler
+ * `MicrofunctionConstants`'ın sabit tavanıdır — ayar daha dar bir tavan koyduysa platform onu
+ * uygular ve gateway'in geçirdiği gövde 422 döner. Ters yön olmaz: buradan geçmeyen gövde
+ * platformda da geçmez.
+ */
+function microfunctionFindings(body) {
+    const provider = isPresent(body.provider) ? String(body.provider) : 'built-in';
+    const sourceKind = isPresent(body.sourceKind) ? String(body.sourceKind) : 'inline';
+    const findings = [];
+    if (provider === 'azure-functions') {
+        findings.push("provider: 'azure-functions' v1'de seçilemez (MicrofunctionProviderNotSupported). Enum değeri tanımlı ama connector'ı yok — 'built-in' (platformun kendi Fission kümesi) ya da 'aws-lambda' kullanın.");
+    }
+    if (provider === 'aws-lambda' && !isPresent(body.runtimeId)) {
+        findings.push("runtimeId: provider 'aws-lambda' iken zorunlu (MicrofunctionRuntimeRequired) — fonksiyonun hangi AWS hesabında koşacağı kayıttan gelir. microfunction_runtime_list ile hesabı seçin.");
+    }
+    if (provider === 'built-in' && isPresent(body.runtimeId)) {
+        findings.push("runtimeId: provider 'built-in' iken VERİLMEZ (MicrofunctionRuntimeNotAllowedForBuiltIn) — Built-In fonksiyon platformun kendi kümesinde koşar, bulut hesabı kaydı yoktur.");
+    }
+    if (sourceKind === 'inline' && !hasText(body.code)) {
+        findings.push("code: sourceKind 'inline' iken zorunlu (MicrofunctionCodeRequired).");
+    }
+    if (sourceKind === 'archive' && !(hasText(body.entrypoint) && MICROFUNCTION_ENTRYPOINT_PATTERN.test(body.entrypoint))) {
+        findings.push(`entrypoint: sourceKind 'archive' iken 'modül.fonksiyon' biçiminde zorunlu (MicrofunctionEntrypointInvalid, desen ${MICROFUNCTION_ENTRYPOINT_PATTERN.source}), ör. 'handlers/sum.handler'.`);
+    }
+    // Komut alanları non-nullable int: gönderilmezse gövdeye 0 gider ve platform 422 döner. Gateway
+    // değer UYDURMAZ (0 ile 30 arasındaki fark faturalandırmayı da davranışı da değiştirir), yalnız
+    // eksikliği çağrıdan önce söyler.
+    const timeoutCeiling = provider === 'aws-lambda' ? 900 : 300;
+    if (!isPresent(body.timeoutSeconds)) {
+        findings.push(`timeoutSeconds: alan non-nullable int — gönderilmezse 0 gider ve platform 422 döner (MicrofunctionTimeoutOutOfRange). 1–${timeoutCeiling} arası bir değer verin (ürün varsayılanı 30).`);
+    }
+    else if (Number(body.timeoutSeconds) < 1 || Number(body.timeoutSeconds) > timeoutCeiling) {
+        findings.push(`timeoutSeconds: ${String(body.timeoutSeconds)} — provider '${provider}' için geçerli aralık 1–${timeoutCeiling} (MicrofunctionTimeoutOutOfRange).`);
+    }
+    if (!isPresent(body.memoryMb)) {
+        findings.push('memoryMb: alan non-nullable int — gönderilmezse 0 gider ve platform 422 döner (MicrofunctionMemoryOutOfRange). 128–3008 arası bir değer verin (ürün varsayılanı 256).');
+    }
+    const environmentVariables = asObject(body.environmentVariables);
+    if (environmentVariables !== undefined) {
+        const invalidKeys = Object.keys(environmentVariables).filter(key => !MICROFUNCTION_ENVIRONMENT_KEY_PATTERN.test(key));
+        const bytes = Object.entries(environmentVariables)
+            .reduce((total, [key, value]) => total + Buffer.byteLength(key, 'utf8') + Buffer.byteLength(value === null || value === undefined ? '' : String(value), 'utf8'), 0);
+        if (invalidKeys.length > 0) {
+            findings.push(`environmentVariables: anahtarlar ${MICROFUNCTION_ENVIRONMENT_KEY_PATTERN.source} desenine uymalı (MicrofunctionEnvironmentVariableKeyInvalid) — uymayanlar: ${invalidKeys.join(', ')}.`);
+        }
+        if (bytes > 4096) {
+            findings.push(`environmentVariables: anahtar+değer toplamı ${bytes} bayt, üst sınır 4096 (Lambda sınırı; MicrofunctionEnvironmentVariablesTooLarge).`);
+        }
+    }
+    return findings;
+}
+function microfunctionRuntimeFindings(body) {
+    const findings = [];
+    if (isPresent(body.provider) && String(body.provider) !== 'aws-lambda') {
+        findings.push(`provider: runtime hesabı v1'de yalnız 'aws-lambda' olabilir (MicrofunctionProviderNotSupported); '${String(body.provider)}' reddedilir. Built-In fonksiyonların runtime kaydı YOKTUR.`);
+    }
+    if (!(hasText(body.roleArn) && MICROFUNCTION_ROLE_ARN_PATTERN.test(body.roleArn))) {
+        findings.push(`roleArn: zorunlu ve ${MICROFUNCTION_ROLE_ARN_PATTERN.source} desenine uymalı (MicrofunctionRuntimeRoleArnInvalid) — fonksiyonun koşacağı Lambda execution rolü, ör. 'arn:aws:iam::123456789012:role/zeyrek-microfunction'.`);
+    }
+    return findings;
+}
+function projectCreateFindings(body) {
+    if (!isPresent(body.templateOptions) && !isPresent(body.application)) {
+        return ["application: 'Application' must not be empty. — templateOptions verilmeyen projede ilk application projeyle birlikte açılır: application { slug, name } zorunlu."];
+    }
+    return [];
+}
+function languageFindings(label, codes) {
+    const unknown = codes.filter(code => !SUPPORTED_LANGUAGES.includes(code));
+    return unknown.length === 0
+        ? []
+        : [`${label}: ${unknown.map(code => `'${code}'`).join(', ')} desteklenen dil listesinde yok — ISO 639-1 iki harfli küçük kod bekleniyor (tr, en, de, fr, …; tam liste ProjectConstants.SupportedLanguages, 184 kod). 'tr-TR' gibi bölge ekli kodlar reddedilir.`];
+}
+function projectUpdateFindings(body) {
+    const findings = [];
+    const languages = Array.isArray(body.languages) ? body.languages.map(String) : undefined;
+    if (languages !== undefined) {
+        if (languages.length === 0)
+            findings.push("languages: en az bir dil verilmeli (Languages.Count > 0).");
+        findings.push(...languageFindings('languages', languages));
+    }
+    if (hasText(body.defaultLanguage) && languages !== undefined && !languages.includes(body.defaultLanguage)) {
+        findings.push(`defaultLanguage: '${body.defaultLanguage}' languages listesinde değil — varsayılan dil listenin elemanı olmalı.`);
+    }
+    return findings;
+}
+function translationFindings(body) {
+    const findings = [];
+    const keys = asObjects(body.keys);
+    const duplicates = duplicateKeys(keys.map(entry => String(entry.key ?? '')));
+    if (duplicates.length > 0)
+        findings.push(`keys: aynı anahtar birden çok kez var: ${duplicates.map(key => `'${key}'`).join(', ')} — her anahtar tek satır (Keys.Select(Key).Distinct().Count() == Count).`);
+    keys.forEach((entry, index) => {
+        if (!hasText(entry.key))
+            findings.push(`keys[${index}].key: boş olamaz.`);
+        const values = asObject(entry.values);
+        if (values === undefined)
+            findings.push(`keys[${index}].values: dil kodu → metin sözlüğü zorunlu.`);
+        else
+            findings.push(...languageFindings(`keys[${index}].values`, Object.keys(values)));
+    });
+    if (Array.isArray(body.deletedKeys) && body.deletedKeys.some(key => !hasText(key)))
+        findings.push('deletedKeys: boş anahtar silinemez.');
+    return findings;
+}
+function externalComponentFindings(body) {
+    const findings = [];
+    if (isPresent(body.protocolVersion) && body.protocolVersion !== EXTERNAL_COMPONENT_PROTOCOL_VERSION) {
+        findings.push(`protocolVersion: ${String(body.protocolVersion)} desteklenmiyor — platform yalnız ${EXTERNAL_COMPONENT_PROTOCOL_VERSION} kabul eder (ExternalComponentProtocolUnsupported).`);
+    }
+    const definition = asObject(body.definition);
+    if (definition === undefined)
+        return [...findings, "definition: 'Definition' must not be empty. — manifest'te definition { blocks, props } zorunlu."];
+    if (!Array.isArray(definition.blocks) || definition.blocks.length === 0) {
+        findings.push('definition.blocks: en az bir blok zorunlu (ExternalComponentBlocksRequired).');
+    }
+    asObjects(definition.props).forEach((prop, index) => {
+        const name = typeof prop.name === 'string' ? prop.name : '';
+        const label = `definition.props[${index}]${name !== '' ? ` ('${name}')` : ''}`;
+        if (name === '')
+            findings.push(`${label}.name: boş olamaz.`);
+        else if (EXTERNAL_COMPONENT_RESERVED_PROPS.includes(name) || name.startsWith('zx') || name.startsWith('on')) {
+            findings.push(`${label}.name: '${name}' ayrılmış prop adı — DOM/host adları (${EXTERNAL_COMPONENT_RESERVED_PROPS.join(', ')}) ile 'zx'/'on' önekleri kullanılamaz (ExternalComponentPropNameReserved).`);
+        }
+        findings.push(...outOfDictionary(`${label}.type`, prop.type, EXTERNAL_COMPONENT_PROP_TYPES));
+    });
+    return findings;
+}
+export const backendRules = [
+    {
+        id: 'ENT-015',
+        module: 'entity',
+        commands: { create: 'CreateEntityCommand', update: 'UpdateEntityCommand' },
+        status: 422,
+        summary: '',
+        sourceRef: 'CreateEntityCommandValidator / UpdateEntityCommandValidator / FieldDtoValidator uzunluk ve NotEmpty kuralları (fieldLimits). Ölçüm: 2026-09-08 3. koşu, index adı 33 karakter → 422',
+        guide: 'ngapps://guides/entity'
+    },
+    {
+        id: 'ENT-016',
+        module: 'entity',
+        commands: { create: 'CreateEntityCommand', update: 'UpdateEntityCommand' },
+        status: 422,
+        summary: "tam 1 primaryKey · alan adları tekil (create 'name', update 'slug' üzerinden, büyük/küçük harf duyarsız)",
+        sourceRef: "CreateEntityCommandValidator: Fields.Count(PrimaryKey) == 1 (PrimaryKeyRequiredException 'Please select exactly one primary key.'); Fields.GroupBy(Name.ToLowerInvariant()).All(Count ≤ 1) (DuplicateValue 'Slug'); UpdateEntityCommandValidator aynı kural Slug üzerinden. Ölçüm: 2026-09-08 3. koşu entity_create 422 (hata #14, #15)",
+        guide: 'ngapps://guides/entity',
+        check: (body, _command, operation) => entityFieldSetFindings(body, operation)
+    },
+    {
+        id: 'ENT-017',
+        module: 'entity',
+        commands: { create: 'CreateEntityCommand', update: 'UpdateEntityCommand' },
+        status: 422,
+        summary: "primaryKey ⇒ nullable:false + hidden:false · identity ⇒ nullable:false · isLocalized ⇒ pk/identity/unique/relation yok · folderId yalnız file · properties.generationType yalnız guid/number · commonType/defaultValueType/relationType sözlükten",
+        sourceRef: 'FieldDtoValidator: When(Identity) Nullable.Equal(false); When(PrimaryKey) Nullable/Hidden.Equal(false); When(IsLocalized) PrimaryKey/Identity/Unique.Equal(false) + RelationType.Equal(None); When(CommonType != File) FolderId.Empty(); When(CommonType ∉ {Guid, Number}) Properties.GenerationType yok; CommonType/DefaultValueType.IsInEnum()',
+        guide: 'ngapps://guides/entity',
+        check: body => entityFieldFlagFindings(body)
+    },
+    {
+        id: 'ENT-018',
+        module: 'entity',
+        commands: { create: 'CreateEntityCommand', update: 'UpdateEntityCommand' },
+        status: 422,
+        summary: "recordTransferMode 'specific' ⇒ transferRowIds dolu, tekil, boşsuz",
+        sourceRef: 'CreateEntityCommandValidator / UpdateEntityCommandValidator: When(RecordTransferMode == Specific) TransferRowIds.NotEmpty() (TransferRecordsRequired); When(TransferRowIds != null) tekrarsız + RuleForEach NotEmpty',
+        guide: 'ngapps://guides/entity',
+        check: body => entityTransferFindings(body)
+    },
+    {
+        id: 'MS-017',
+        module: 'microservice',
+        commands: { create: 'CreateMicroserviceCommand', update: 'UpdateMicroserviceCommand' },
+        status: 422,
+        summary: "queryId/entityId/workflowId verilirse boş GUID olamaz · source:'expression' alan/filtrede value dolu · tekil filtrede fieldId · writeOn yalnız upsert'te · join'de entityId+fieldId",
+        sourceRef: 'CreateMicroserviceCommandValidator / UpdateMicroserviceCommandValidator: Name/Url NotEmpty (update: Slug da); QueryId/EntityId/WorkflowId NotEqual(Guid.Empty); SourceParameters.Fields/Filters.Where(Source == Expression).Must(Value dolu); Filters.Where(Single).All(FieldId dolu); Table && Operation != Upsert ⇒ Fields.All(WriteOn == Always); Joins alias+entityId+fieldId (TableSourceJoinIncomplete). enableDynamicFilters kümesi MS-010, alias MS-005, selectFields MS-006',
+        guide: 'ngapps://guides/microservice',
+        check: body => microserviceFindings(body)
+    },
+    {
+        id: 'WF-026',
+        module: 'workflow',
+        commands: { create: 'CreateWorkflowCommand', update: 'UpdateWorkflowCommand', preview: 'PreviewWorkflowCommand' },
+        status: 422,
+        summary: "returnDtoId ⇒ returnBehavior, parameterDtoId ⇒ parameterBehavior (primitive|object|array); update/preview'da DTO yokken behavior null · type:'workflow' + parameterDtoId yok ⇒ previewPayload yok · variable adımı 'user' adını alamaz · tekil filtrede fieldId · automation: parameterDtoId yok, isQueue ⇒ queueOrder ≥ 0",
+        sourceRef: 'CreateWorkflowCommandValidator / UpdateWorkflowCommandValidator / PreviewWorkflowCommandValidator: Name/Slug NotEmpty; When(ReturnDtoId.HasValue) ReturnBehavior NotEmpty (update/preview: IsInEnum, null ⇒ Null()); ParameterDtoId aynı; When(ParameterDtoId null && Type == Workflow) PreviewPayload.Null() (PreviewPayloadRequiresParameterDto); Steps.Must(!Variable && Rule.Name == "user"); RuleForEach(Steps) Rule.Filters single ⇒ FieldId; When(Automation) ParameterDtoId.Empty(); AutomationValidation: When(IsQueue) QueueOrder NotEmpty + ≥ 0. Start adımı/graf WF-001, response yasağı WF-005, isQueue/operation/returnDtoId WF-010',
+        guide: 'ngapps://guides/workflow',
+        check: (body, _command, operation) => workflowFindings(body, operation)
+    },
+    {
+        id: 'QRY-001',
+        module: 'query',
+        commands: { create: 'CreateQueryCommand', update: 'UpdateQueryCommand', preview: 'PreviewQueryCommand' },
+        status: 422,
+        summary: "rawQuery'deki her @ad / {{ad}} parameters[]'ta bildirilir (create) · outputType array|object · preview parametrelerinde name zorunlu",
+        sourceRef: "CreateQueryCommandValidator: Slug/RawQuery NotEmpty, DatasourceId NotEqual(Guid.Empty), Parameters.Must(RawQueryParameterNames ⊆ Parameters.Name) (QueryParametersMissing); UpdateQueryCommandValidator aynı, parametre denetimi YOK; PreviewQueryCommandValidator: RawQuery NotEmpty, Parameters[].Name NotEmpty; OutputType.IsInEnum(). Desen Query.RawQueryParameterPattern",
+        guide: 'ngapps://guides/microservice',
+        check: (body, _command, operation) => queryFindings(body, operation)
+    },
+    {
+        id: 'VIEW-001',
+        module: 'view',
+        commands: { create: 'CreateViewCommand', update: 'UpdateViewCommand' },
+        status: 422,
+        summary: "providerType 'postgres'",
+        sourceRef: 'CreateViewCommandValidator / UpdateViewCommandValidator: Name NotEmpty, ProviderType.IsInEnum() (tek değer: postgres)',
+        guide: 'ngapps://guides/view',
+        check: body => viewFindings(body)
+    },
+    {
+        id: 'DTO-001',
+        module: 'dto',
+        commands: { create: 'CreateDataTransferObjectCommand', update: 'UpdateDataTransferObjectCommand' },
+        status: 422,
+        summary: 'type sözlükten (object|array|bool|string|number|float|guid|date|time|datetime|file|anonymous) · children[].slug zorunlu ve kardeşler arasında tekil · referenceId yalnız object/array çocukta',
+        sourceRef: 'CreateDataTransferObjectCommandValidator / UpdateDataTransferObjectCommandValidator: Name/Slug NotEmpty, Type.IsInEnum(), Children.GroupBy(Slug.ToLowerInvariant()).All(Count ≤ 1); DataTransferObjectDtoValidator (özyineli): Slug NotEmpty (DataTransferObjectChildSlugRequired), Type.IsInEnum(), When(ReferenceId) Type ∈ {Object, Array}',
+        guide: 'ngapps://guides/workflow',
+        check: body => dtoFindings(body)
+    },
+    {
+        id: 'ROW-002',
+        module: 'row',
+        commands: { create: 'CreateRowCommand', update: 'UpdateRowCommand' },
+        status: 422,
+        summary: 'satır sözlüğü boş olamaz, boş anahtar taşıyamaz, bütün değerleri null olamaz (toplu yolda her satır için)',
+        sourceRef: 'CreateRowCommandValidator / UpdateRowCommandValidator / CreateBulkRowCommandValidator / UpdateBulkRowCommandValidator: Row NotEmpty, Keys.Count > 0, !Keys.Any(IsNullOrWhiteSpace), !Values.All(null)',
+        guide: 'ngapps://guides/entity',
+        commandFor: (body, operation) => Array.isArray(body.rows)
+            ? (operation === 'create' ? 'CreateBulkRowCommand' : 'UpdateBulkRowCommand')
+            : (operation === 'create' ? 'CreateRowCommand' : 'UpdateRowCommand'),
+        check: body => rowFindings(body)
+    },
+    {
+        id: 'DS-001',
+        module: 'datasource',
+        commands: { create: 'CreateDatasourceCommand', update: 'UpdateDatasourceCommand' },
+        status: 422,
+        summary: "type postgresql|mongodb · postgresql ⇒ properties.initialDatabase ≤63, userName ≤63, password ≤1024 (üçü zorunlu) · mongodb + authenticationType 'password' ⇒ authenticationDatabase/userName/password",
+        sourceRef: 'CreateDatasourceCommandValidator / UpdateDatasourceCommandValidator (fieldLimits) + PostgreSqlPropertyValidator + MongoDbPropertyValidator (authenticationType ∈ MongoDbAuthenticationType.Values)',
+        check: body => datasourceFindings(body)
+    },
+    {
+        id: 'PRJ-001',
+        module: 'project',
+        commands: { create: 'CreateOrganizationProjectCommand' },
+        status: 409,
+        summary: "templateOptions yoksa application zorunlu · slug organizasyonda tekil (veritabanı adı zeyrek_<org>_<slug>; çakışma eski build'de 500, 2026-09-08 sonrası 409)",
+        sourceRef: "CreateOrganizationProjectCommandValidator: When(TemplateOptions null) Application.NotNull(); OrganizationProjectService.CreateAsync: ExistsByOrganizationAndDatabaseNameAsync ⇒ DatabaseNameAlreadyExistsException (ExceptionHandler eşlemesi 2026-09-08'de 409'a alındı). Gateway POST'tan önce project_list ile slug'ı arar. Ölçüm: 2026-09-08 3. koşu S-1 / P3-7",
+        check: body => projectCreateFindings(body)
+    },
+    {
+        id: 'PRJ-002',
+        module: 'project',
+        commands: { update: 'UpdateOrganizationProjectCommand' },
+        status: 422,
+        summary: 'languages ⊆ ISO 639-1 (184 kod), boş olamaz · defaultLanguage languages içinde',
+        sourceRef: 'UpdateOrganizationProjectCommandValidator: When(Languages != null) Count > 0 && All(ProjectConstants.SupportedLanguages.Contains); When(DefaultLanguage) Languages null || Languages.Contains(DefaultLanguage)',
+        check: body => projectUpdateFindings(body)
+    },
+    {
+        id: 'TR-001',
+        module: 'translation',
+        commands: { update: 'UpdateTranslationsCommand' },
+        status: 422,
+        summary: 'keys[].key boş olamaz ve tekil · values dil kodları ISO 639-1 · deletedKeys boş olamaz',
+        sourceRef: 'UpdateTranslationsCommandValidator: Keys.All(Key dolu), Keys.Select(Key).Distinct().Count() == Count, Keys.All(Values.Keys ⊆ SupportedLanguages), DeletedKeys.All(dolu)',
+        guide: 'ngapps://guides/translation',
+        check: body => translationFindings(body)
+    },
+    {
+        id: 'FLD-001',
+        module: 'folder',
+        commands: { create: 'CreateFolderCommand' },
+        status: 422,
+        summary: "name zorunlu ve \\|!#~$%&/=?»«@£§€{};'<>, karakterlerini içeremez (dosya adı için de aynı küme: FILE-001)",
+        sourceRef: 'CreateFolderCommandValidator: Name.NotEmpty().Must(StringExtensions.IsContainsSpecialChar) — yardımcı, ad ne derse desin "yasak karakter YOK" demektir',
+        check: body => nameCharacterFindings('name', body.name)
+    },
+    {
+        id: 'FILE-001',
+        module: 'file',
+        commands: { create: 'UploadFileCommand' },
+        status: 422,
+        summary: "dosya adı \\|!#~$%&/=?»«@£§€{};'<>, karakterlerini içeremez",
+        sourceRef: 'UploadFileCommandValidator: File.NotNull(), File.Must(IsContainsSpecialChar(FileName))',
+        check: body => nameCharacterFindings('filename', body.filename)
+    },
+    {
+        id: 'MF-001',
+        module: 'microfunction',
+        commands: { create: 'CreateMicrofunctionCommand', update: 'UpdateMicrofunctionCommand' },
+        status: 422,
+        summary: "provider 'built-in' ⇒ runtimeId boş, 'aws-lambda' ⇒ runtimeId zorunlu, 'azure-functions' reddedilir · sourceKind 'inline' ⇒ code, 'archive' ⇒ 'modül.fonksiyon' biçiminde entrypoint · timeoutSeconds ve memoryMb GÖNDERİLMEK ZORUNDA (non-nullable int, eksikse 0 gider) · env anahtarları ^[A-Z_][A-Z0-9_]*$ ve toplam ≤ 4 KB",
+        sourceRef: 'CreateMicrofunctionCommandValidator / UpdateMicrofunctionCommandValidator (ikisi birebir aynı kural kümesi) + MicrofunctionConstants (EntrypointPattern, EnvironmentVariableKeyPattern, BuiltInMaxTimeoutSeconds 300, CloudMaxTimeoutSeconds 900, MinMemoryMb 128, MaxMemoryMb 3008, MaxEnvironmentVariablesBytes 4096)',
+        guide: 'ngapps://guides/microfunction',
+        check: body => microfunctionFindings(body)
+    },
+    {
+        id: 'MFR-001',
+        module: 'microfunctionRuntime',
+        commands: { create: 'CreateMicrofunctionRuntimeCommand', update: 'UpdateMicrofunctionRuntimeCommand' },
+        status: 422,
+        summary: "provider yalnız 'aws-lambda' · roleArn zorunlu ve arn:aws:iam::<12 hane>:role/<ad> desenli",
+        sourceRef: 'CreateMicrofunctionRuntimeCommandValidator / UpdateMicrofunctionRuntimeCommandValidator + MicrofunctionConstants.RoleArnPattern',
+        guide: 'ngapps://guides/microfunction',
+        check: body => microfunctionRuntimeFindings(body)
+    },
+    {
+        id: 'EXT-001',
+        module: 'externalComponent',
+        commands: { create: 'PublishExternalComponentCommand' },
+        status: 422,
+        summary: 'protocolVersion 1 · definition.blocks dolu · props[].name ayrılmış DOM adı ya da zx/on önekli olamaz · props[].type sözlükten',
+        sourceRef: 'PublishExternalComponentCommandValidator: ProtocolVersion.Must(SupportsProtocolVersion), Definition.Blocks NotEmpty, Props[].Name !IsReservedPropName, Props[].Type IsAllowedPropType (ExternalComponentRules). Slug deseni ve 2 MB paket sınırı tool\'da ayrıca denetlenir',
+        guide: 'ngapps://guides/external-component',
+        check: body => externalComponentFindings(body)
+    }
+];
+function ruleFindings(rule, body, operation) {
+    const command = rule.commandFor?.(body, operation) ?? rule.commands[operation];
+    if (command === undefined)
+        return [];
+    const messages = [...limitFindings(command, body, rule.id), ...(rule.check?.(body, command, operation) ?? [])];
+    return messages.map(message => ({
+        ruleId: rule.id,
+        severity: 'block',
+        message: `${message} [platform ${rule.status} ile reddederdi — ${command}]`,
+        ...(rule.guide !== undefined ? { guide: rule.guide } : {})
+    }));
+}
+/**
+ * Her backend kuralı bir politika kuralı olarak `policyRules`'a katılır. Şiddet `block`: kural
+ * platformun kendi doğrulayıcısının aynasıdır, gövde gitseydi aynı red gelecekti; gidiş-dönüşü
+ * ve araştırma turunu kısaltmak dışında yeni bir yargı taşımaz. `policyOverride` / `POLICY=warn`
+ * kaçışları aynen geçerlidir — ayna yanlışsa istek yine gönderilebilir.
+ */
+export function backendPolicyRules() {
+    return backendRules.map(rule => ({
+        id: rule.id,
+        module: rule.module,
+        appliesTo: Object.keys(rule.commands),
+        sourceRef: rule.sourceRef,
+        check: (definition, context) => ruleFindings(rule, definition, context.operation)
+    }));
+}
+function limitLabel(limit) {
+    const parts = [limit.path];
+    if (limit.required)
+        parts.push('zorunlu');
+    if (limit.maxLength !== undefined)
+        parts.push(`≤${limit.maxLength}`);
+    if (limit.minLength !== undefined && limit.minLength > 1)
+        parts.push(`≥${limit.minLength}`);
+    if (limit.range !== undefined)
+        parts.push(`${Number.isFinite(limit.range[0]) ? limit.range[0] : '…'}–${Number.isFinite(limit.range[1]) ? limit.range[1] : '…'}`);
+    if (limit.pattern !== undefined)
+        parts.push(`desen ${limit.pattern}`);
+    if (limit.minItems !== undefined)
+        parts.push(`en az ${limit.minItems} eleman`);
+    return parts.join(' ');
+}
+/** Tool açıklamasına giren tek satır: ajan sınırı çağrıdan ÖNCE görür, 422 ile öğrenmez. */
+export function constraintSummary(command) {
+    const rules = backendRules.filter(rule => Object.values(rule.commands).includes(command));
+    const limits = effectiveLimits(command).filter(limit => limitLabel(limit) !== limit.path).map(limitLabel);
+    const summaries = rules.map(rule => rule.summary).filter(summary => summary !== '');
+    const entries = [...limits, ...summaries];
+    if (entries.length === 0)
+        return '';
+    return `Backend ön kontrolü (${rules.map(rule => rule.id).join(' · ')}; block, istek gitmeden): ${entries.join(' · ')}. Tam katalog: ngapps://rules/backend-constraints.`;
+}
+export function constraintCatalog() {
+    return {
+        source: "zeyrek-backend FluentValidation doğrulayıcıları (Application/Contexts/**/*Command.cs, *Dto.cs) + ExceptionHandler eşlemesi; gateway'in politika lint'i aynı kuralı istek gitmeden uygular (block). Koşulsuz uzunluk/zorunluluk kuralları 2026-09-08'den beri swagger'dan (MicroElements.Swashbuckle.FluentValidation) paketlenmiş şemaya akar ve burada `sourceRef` 'swagger ← FluentValidation' olarak görünür; el yazımı satırlar şemanın ifade edemediği kuralları taşır.",
+        note: "Mesajlar platformun 422 gövdesindeki cümlelerdir; ID'ler zeyrek-mcp/docs/08-kural-envanteri.md'de. policyOverride: true ya da POLICY=warn kuralı warn'a indirir.",
+        rules: backendRules.map(rule => ({
+            id: rule.id,
+            module: rule.module,
+            status: rule.status,
+            commands: rule.commands,
+            summary: rule.summary,
+            limits: Object.values(rule.commands)
+                .flatMap(command => effectiveLimits(command).filter(limit => limit.ruleId === rule.id))
+                .map(limit => ({
+                command: limit.command,
+                path: limit.path,
+                ...(limit.required ? { required: true } : {}),
+                ...(limit.guid ? { guid: true } : {}),
+                ...(limit.maxLength !== undefined ? { maxLength: limit.maxLength } : {}),
+                ...(limit.minLength !== undefined ? { minLength: limit.minLength } : {}),
+                ...(limit.range !== undefined ? { range: limit.range.map(bound => Number.isFinite(bound) ? bound : null) } : {}),
+                ...(limit.pattern !== undefined ? { pattern: limit.pattern } : {}),
+                ...(limit.minItems !== undefined ? { minItems: limit.minItems } : {}),
+                sourceRef: limit.sourceRef
+            })),
+            sourceRef: rule.sourceRef,
+            ...(rule.guide !== undefined ? { guide: rule.guide } : {})
+        })),
+        dictionaries: {
+            supportedLanguages: SUPPORTED_LANGUAGES,
+            forbiddenNameCharacters: FORBIDDEN_NAME_CHARACTERS,
+            externalComponent: {
+                protocolVersion: EXTERNAL_COMPONENT_PROTOCOL_VERSION,
+                propTypes: EXTERNAL_COMPONENT_PROP_TYPES,
+                reservedProps: EXTERNAL_COMPONENT_RESERVED_PROPS,
+                reservedPrefixes: ['zx', 'on'],
+                slugPattern: '^x-[a-z][a-z0-9-]*$',
+                maxBundleBytes: 2 * 1024 * 1024
+            }
+        }
+    };
+}