@appaflytech/zeyrek-ai-mcp 0.0.35 → 0.0.37

package/dist/knowledge/decision.js

@@ -0,0 +1,121 @@
+const guide = 'ngapps://guides/decision';
+/**
+ * b-81 `FeelExpressionResolver.FunctionNames` ile birebir. Backend doğrulayıcısı her ifadeyi YAZIMDA
+ * ayrıştırır ve listede olmayan çağrıyı 422 ile reddeder (içe aktarma dahil); gateway istek gitmeden
+ * uyarır (DMN-002). Denetim sözcük tabanlı ve sezgisel olduğu için block değil warn.
+ */
+export const feelFunctionNames = new Set([
+    'years and months duration', 'date and time', 'string length', 'upper case', 'lower case', 'starts with', 'ends with',
+    'list contains', 'substring before', 'substring after', 'distinct values', 'index of', 'get value',
+    'date', 'time', 'duration', 'substring', 'contains', 'matches', 'replace', 'string', 'number', 'not',
+    'count', 'sum', 'product', 'min', 'max', 'mean', 'all', 'any', 'append', 'concatenate', 'flatten', 'reverse',
+    'abs', 'floor', 'ceiling', 'decimal', 'modulo', 'sqrt', 'odd', 'even'
+]);
+const feelKeywords = new Set(['if', 'then', 'else', 'and', 'or', 'in', 'between', 'return', 'satisfies', 'for', 'some', 'every', 'function', 'instance', 'of']);
+const wildcardEntries = new Set(['', '-']);
+function asObjects(value) {
+    return (Array.isArray(value) ? value : []).filter((entry) => Boolean(entry) && typeof entry === 'object' && !Array.isArray(entry));
+}
+function asStrings(value) {
+    return (Array.isArray(value) ? value : []).map(entry => typeof entry === 'string' ? entry : '');
+}
+function normalizedEntry(entry) {
+    return entry.replace(/\s+/g, ' ').trim();
+}
+/**
+ * Çok sözcüklü FEEL işlev adı ("string length(") sözcük dizisinin SONEKİdir: önündeki "if"
+ * gibi anahtar sözcükler ve değişken adları çağrının parçası değildir. Bilinen bir sonek yoksa
+ * anahtar sözcükler atılıp kalan dizi bilinmeyen işlev adı sayılır.
+ */
+export function unknownFeelFunctions(expression) {
+    const withoutStrings = expression.replace(/"(?:[^"\\]|\\.)*"/g, '""');
+    const unknown = [];
+    for (const match of withoutStrings.matchAll(/([A-Za-z_][A-Za-z0-9_]*(?:[ \t]+[A-Za-z_][A-Za-z0-9_]*)*)[ \t]*\(/g)) {
+        const words = (match[1] ?? '').split(/[ \t]+/);
+        if (feelKeywords.has(words[words.length - 1]))
+            continue;
+        const isKnown = words.some((_, index) => feelFunctionNames.has(words.slice(index).join(' ')));
+        if (isKnown)
+            continue;
+        let firstNameIndex = 0;
+        while (firstNameIndex < words.length && feelKeywords.has(words[firstNameIndex]))
+            firstNameIndex++;
+        const name = words.slice(firstNameIndex).join(' ');
+        if (name !== '' && !unknown.includes(name))
+            unknown.push(name);
+    }
+    return unknown;
+}
+function decisionExpressions(decision) {
+    const expressions = [];
+    asObjects(decision.inputs).forEach((input, index) => {
+        if (typeof input.expression === 'string')
+            expressions.push({ path: `/inputs/${index}/expression`, expression: input.expression });
+        if (typeof input.allowedValues === 'string')
+            expressions.push({ path: `/inputs/${index}/allowedValues`, expression: input.allowedValues });
+    });
+    asObjects(decision.outputs).forEach((output, index) => {
+        if (typeof output.defaultOutputEntry === 'string')
+            expressions.push({ path: `/outputs/${index}/defaultOutputEntry`, expression: output.defaultOutputEntry });
+    });
+    asObjects(decision.rules).forEach((rule, ruleIndex) => {
+        asStrings(rule.inputEntries).forEach((entry, entryIndex) => expressions.push({ path: `/rules/${ruleIndex}/inputEntries/${entryIndex}`, expression: entry }));
+        asStrings(rule.outputEntries).forEach((entry, entryIndex) => expressions.push({ path: `/rules/${ruleIndex}/outputEntries/${entryIndex}`, expression: entry }));
+    });
+    if (typeof decision.literalExpression === 'string')
+        expressions.push({ path: '/literalExpression', expression: decision.literalExpression });
+    return expressions;
+}
+/**
+ * DMN-001 (block): `unique` tabloda iki kural her girdi sütununda aynı testi ya da joker (`-`)
+ * taşıyorsa aynı girdi ikisini de eşler ve motor 422 `DecisionHitPolicyViolated` döner. Denetim
+ * statik ve temkinlidir: yalnız KESİN çakışmayı yakalar, kesişen aralıkları (`< 10` ve `< 20`)
+ * yakalamaz — o çakışma `decision_preview` ile görülür.
+ * DMN-002 (warn): b-81 FEEL alt kümesinde olmayan işlev çağrısı; backend yazımı 422 ile reddeder.
+ */
+export function decisionFindings(decision) {
+    const findings = [];
+    const hitPolicy = typeof decision.hitPolicy === 'string' ? decision.hitPolicy : 'unique';
+    const kind = typeof decision.kind === 'string' ? decision.kind : 'table';
+    if (kind === 'table' && hitPolicy === 'unique') {
+        const rules = asObjects(decision.rules);
+        const columnCount = asObjects(decision.inputs).length;
+        for (let left = 0; left < rules.length; left++) {
+            for (let right = left + 1; right < rules.length; right++) {
+                const leftEntries = asStrings(rules[left].inputEntries).map(normalizedEntry);
+                const rightEntries = asStrings(rules[right].inputEntries).map(normalizedEntry);
+                const overlaps = Array.from({ length: Math.max(columnCount, leftEntries.length, rightEntries.length) }, (_, column) => {
+                    const leftEntry = leftEntries[column] ?? '';
+                    const rightEntry = rightEntries[column] ?? '';
+                    return wildcardEntries.has(leftEntry) || wildcardEntries.has(rightEntry) || leftEntry === rightEntry;
+                }).every(Boolean);
+                if (!overlaps)
+                    continue;
+                const leftId = String(rules[left].id ?? `#${left + 1}`);
+                const rightId = String(rules[right].id ?? `#${right + 1}`);
+                findings.push({
+                    ruleId: 'DMN-001',
+                    severity: 'block',
+                    message: `'${String(decision.slug ?? '')}' unique tablosunda '${leftId}' ve '${rightId}' kuralları aynı girdiyi eşler (her sütunda aynı test ya da '-'); değerlendirme 422 DecisionHitPolicyViolated döner. Kuralları ayırın ya da hitPolicy 'first' / 'priority' / 'collect' seçin.`,
+                    guide
+                });
+            }
+        }
+    }
+    const unknownByName = new Map();
+    for (const { path, expression } of decisionExpressions(decision)) {
+        for (const name of unknownFeelFunctions(expression)) {
+            if (!unknownByName.has(name))
+                unknownByName.set(name, path);
+        }
+    }
+    for (const [name, path] of unknownByName) {
+        findings.push({
+            ruleId: 'DMN-002',
+            severity: 'warn',
+            message: `FEEL işlevi '${name}' (${path}) motorun alt kümesinde yok; backend yazımı (create, update, patch, DMN içe aktarma) 422 ile reddeder. Desteklenenler platform_guide('decision') §FEEL; ör. yuvarlama için decimal(x, 0), floor, ceiling.`,
+            guide
+        });
+    }
+    return findings;
+}

package/dist/knowledge/expressionPrelude.js

@@ -0,0 +1,59 @@
+import { FUNCTIONS_NAMESPACE } from './functionGuards.js';
+/**
+ * İstemci ifade preamble'ının ayrılmış adları — `zeyrek-frontend/packages/ng-apps-flow/src/
+ * flow-execution.functions.ts` `EXPRESSION_PRELUDE_NAMES` ile BİREBİR (elle aynalanır, sürüklenmeyi
+ * `test/expression-prelude-parity.test.ts` yakalar). Runtime `Components` anahtarlarını
+ * `key.replace('-', '')` (YALNIZ ilk tire) ile tanımlayıcıya çevirir ve bu kümedeki adı uyarıyla
+ * ELER: o komponent sayfadaki hiçbir ifadede görünmez (ARC-143, PAGE-009).
+ */
+export const EXPRESSION_PRELUDE_NAMES = [
+    'payload',
+    FUNCTIONS_NAMESPACE,
+    'machine',
+    'params',
+    '_PROXY_TAG',
+    '_STATE_PROXY_TAG',
+    'Components',
+    'Page',
+    '_stripProxy',
+    '_buildPath',
+    '_resolveStateProxy',
+    '_stripStateProxy',
+    'log',
+    '_statePathValue',
+    'createStateScopeProxy',
+    'state',
+    'Steps',
+    'error',
+    'Widget',
+    'LocalStorage',
+    'Device',
+    'Section',
+    'Row',
+    'RowIndex',
+    '_eventSourceId',
+    '_eventSourceNode',
+    'event',
+    'item',
+    'self',
+    'addSetters',
+    '_rawComponents',
+    '_eventParams',
+    'repeaterId',
+    'setComponentProperty',
+    'getComponentProperty',
+    'resetForm',
+    't',
+    'cookie',
+    '__fnArgs'
+];
+const RESERVED_EXPRESSION_NAMES = new Set(EXPRESSION_PRELUDE_NAMES);
+/**
+ * Komponent adının runtime'daki ifade tanımlayıcısı ayrılmışsa o tanımlayıcıyı döndürür. Tire
+ * işleme runtime'la aynıdır (yalnız ilk `-` silinir): `ite-m` → `item` gizlenir, `i-te-m` →
+ * `ite-m` gizlenmez.
+ */
+export function reservedExpressionName(componentName) {
+    const identifier = componentName.replace('-', '');
+    return RESERVED_EXPRESSION_NAMES.has(identifier) ? identifier : undefined;
+}

package/dist/knowledge/layoutSummary.js

@@ -1,10 +1,148 @@
-export function summarizeLayout(boxes, viewport) {
+import { MOBILE_DROPPABLE_TYPES, MOBILE_INTRINSIC_WIDTH_TYPES, MOBILE_OUT_OF_FLOW_TYPES, MOBILE_TRANSPARENT_WRAPPER_TYPES } from './mobileComponentCatalog.js';
+const SPACING_SCALE = [0, 4, 8, 16, 24, 32];
+const EDGE_TOLERANCE = 1;
+const WIDTH_TOLERANCE = 2;
+export function summarizeLayout(boxes, viewport, options = {}) {
     const outside = (box) => box.x + box.width <= 0 || box.y + box.height <= 0 || box.x >= viewport.width || box.y >= viewport.height;
+    const alignment = options.alignment === true ? summarizeAlignment(boxes, viewport) : undefined;
     return {
         nodeCount: boxes.length,
         overflowing: boxes.filter(box => box.overflowX || box.overflowY).map(box => box.elementId),
         outsideViewport: boxes.filter(box => box.width > 0 && box.height > 0 && outside(box)).map(box => box.elementId),
         zeroSized: boxes.filter(box => box.width === 0 || box.height === 0).map(box => box.elementId),
-        truncated: boxes.length >= 500
+        truncated: boxes.length >= 500,
+        ...(alignment ? { alignment } : {})
     };
 }
+function summarizeAlignment(boxes, viewport) {
+    // Tip ve ata sırası olmayan kutular (eski runtime/betik) ağaç kurmaz; hiza uydurulmaz.
+    if (!boxes.some(box => typeof box.type === 'string' && box.parentIndex !== undefined))
+        return undefined;
+    // Ağaç sırayla kurulur, kimlikle değil: `repeater` aynı elementId'yi her satırda yeniden çizer.
+    const parentOf = (box) => typeof box.parentIndex === 'number' ? boxes[box.parentIndex] : undefined;
+    // İç roller (`__trigger`, `__press`) tip taşımaz: bileşenin parçasıdır, düğüm değildir.
+    const typedParent = (box) => {
+        for (let current = parentOf(box); current; current = parentOf(current))
+            if (current.type)
+                return current;
+        return undefined;
+    };
+    const ancestors = (box) => {
+        const chain = [];
+        for (let current = typedParent(box); current; current = typedParent(current))
+            chain.push(current);
+        return chain;
+    };
+    // Ana ağacın kökü en büyük atasız kutudur. Öteki atasız kutular portala çizilir (floating-container,
+    // toast, modal içeriği) ve akışta değildir; sayılsalar ana kökü "yan yana kardeş" yapar, ekran satır sayılırdı.
+    // Sayfanın ağacını taşıyan kök seçilir (kabuklu sayfada shell_root, kabuksuzda page_container); bulunamazsa
+    // en büyük kök, eşitlikte sonraki — portal içeriği DOM'da uygulamadan önce durur.
+    const roots = boxes.filter(box => box.type && !typedParent(box));
+    const pageContainer = boxes.find(box => box.elementId === 'page_container');
+    const mainRoot = (pageContainer ? [pageContainer, ...ancestors(pageContainer)].at(-1) : undefined)
+        ?? [...roots].reverse().sort((a, b) => b.width * b.height - a.width * a.height)[0];
+    // Saydam sarmalayıcının (tooltip) kutusu görünmez; dikey aralık onun görünen içeriğinden ölçülür.
+    const visibleExtent = (box) => {
+        const children = MOBILE_TRANSPARENT_WRAPPER_TYPES.includes(box.type ?? '') ? boxes.filter(child => child.type && typedParent(child) === box && child.height > 0) : [];
+        return children.length === 0
+            ? { top: box.y, bottom: box.y + box.height }
+            : { top: Math.min(...children.map(child => child.y)), bottom: Math.max(...children.map(child => child.y + child.height)) };
+    };
+    const outOfFlow = (box) => {
+        const chain = [box, ...ancestors(box)];
+        return chain.some(item => MOBILE_OUT_OF_FLOW_TYPES.includes(item.type ?? '')) || chain[chain.length - 1] !== mainRoot;
+    };
+    // Yatayda ekrana sığmayan kutu (carousel ya da yatay kaydırmanın öteki sayfaları) sütun akışında değildir.
+    const onScreen = (box) => box.x >= -EDGE_TOLERANCE && box.x + box.width <= viewport.width + EDGE_TOLERANCE;
+    const flow = boxes.filter(box => box.type && box.width > 0 && box.height > 0 && onScreen(box) && !outOfFlow(box));
+    const inFlow = new Set(flow);
+    const parents = new Set(flow.map(typedParent).filter(Boolean));
+    const siblings = (box) => flow.filter(other => other !== box && typedParent(other) === typedParent(box));
+    const besideSibling = (box) => siblings(box).some(other => other.y < box.y + box.height - EDGE_TOLERANCE && box.y < other.y + other.height - EDGE_TOLERANCE);
+    // Kapsam, kendi kapsamından dar bir yüzeydir. Kapsamı boydan boya kaplayan zemin (boyanmış sayfa kökü,
+    // tam genişlik bant) yeni kapsam açmaz; içeriği ekranın kenar ölçüsüne girer.
+    const scopeCache = new Map();
+    const scopeOf = (box) => {
+        if (scopeCache.has(box))
+            return scopeCache.get(box);
+        const scope = ancestors(box).find(item => inFlow.has(item) && opensScope(item));
+        scopeCache.set(box, scope);
+        return scope;
+    };
+    const opensScope = (box) => box.surface === true && box.width < (scopeOf(box)?.width ?? viewport.width) - WIDTH_TOLERANCE;
+    // Yan yana dizilen öğe (satır kabının çocuğu ya da onun içindeki sütun) sütun hizasına girmez.
+    const inRow = (box) => {
+        const scope = scopeOf(box);
+        const chain = [box, ...ancestors(box)];
+        return chain.slice(0, scope ? chain.indexOf(scope) : chain.length).some(besideSibling);
+    };
+    const isContent = (box) => parents.has(box)
+        ? opensScope(box)
+        : box.surface === true || !MOBILE_DROPPABLE_TYPES.includes(box.type ?? '');
+    const scopes = new Map([[undefined, []]]);
+    for (const box of flow.filter(isContent)) {
+        const scope = scopeOf(box);
+        if (box.width >= (scope?.width ?? viewport.width) / 2 && !inRow(box))
+            scopes.set(scope, [...(scopes.get(scope) ?? []), box]);
+    }
+    const reports = [...scopes].map(([scope, members]) => ({ scope, ...scopeAlignment(members) }));
+    const screen = reports.find(report => report.scope === undefined);
+    return {
+        gutter: screenGutter(screen?.dominantLeft, screen?.dominantRight, viewport.width),
+        leftEdges: screen?.leftEdges ?? [],
+        surfaces: reports.filter(report => report.scope !== undefined && report.leftEdges.length > 1).map(report => ({ elementId: report.scope?.elementId ?? '', leftEdges: report.leftEdges })),
+        widthOutliers: reports.flatMap(report => report.widthOutliers),
+        offScaleGaps: offScaleGaps(flow, typedParent, visibleExtent)
+    };
+}
+function scopeAlignment(members) {
+    const leftEdges = clusters(members, box => box.x);
+    const sized = members.filter(box => !MOBILE_INTRINSIC_WIDTH_TYPES.includes(box.type ?? ''));
+    // Yalnız içerik genişlikli öğe varsa (metin listesi) sağ kenar onlardan okunur; sapma yine sayılmaz.
+    const rightEdges = clusters(sized.length > 0 ? sized : members, box => box.x + box.width);
+    // Eşitlikte en soldaki sol kenar ve en sağdaki sağ kenar kazanır: sözleşmenin normu `fill`dir.
+    const dominantLeft = [...leftEdges].sort((a, b) => b.elementIds.length - a.elementIds.length || a.x - b.x)[0]?.x;
+    const dominantRight = [...rightEdges].sort((a, b) => b.elementIds.length - a.elementIds.length || b.x - a.x)[0]?.x;
+    const widthOutliers = dominantLeft === undefined || dominantRight === undefined
+        ? []
+        : unique(sized.filter(box => Math.abs(box.x + box.width - dominantRight) > WIDTH_TOLERANCE), box => box.elementId)
+            .map(box => ({ elementId: box.elementId, insetLeft: box.x - dominantLeft, insetRight: dominantRight - (box.x + box.width) }));
+    return { leftEdges, dominantLeft, dominantRight, widthOutliers };
+}
+const unique = (items, key) => items.filter((item, index) => items.findIndex(other => key(other) === key(item)) === index);
+function clusters(members, edge) {
+    const result = [];
+    for (const box of members) {
+        const match = result.find(cluster => Math.abs(cluster.x - edge(box)) <= EDGE_TOLERANCE);
+        if (match && !match.elementIds.includes(box.elementId))
+            match.elementIds.push(box.elementId);
+        else if (!match)
+            result.push({ x: edge(box), elementIds: [box.elementId] });
+    }
+    return result.sort((a, b) => a.x - b.x);
+}
+function screenGutter(left, right, width) {
+    if (left === undefined || right === undefined)
+        return null;
+    const rightGutter = width - right;
+    return Math.abs(left - rightGutter) <= EDGE_TOLERANCE ? left : { left, right: rightGutter };
+}
+/** Aynı atanın alt alta duran ardışık çocukları arasındaki boşluk ölçekte mi (yan yana olanlar sayılmaz). */
+function offScaleGaps(flow, typedParent, extent) {
+    const groups = new Map();
+    for (const box of flow) {
+        const key = typedParent(box);
+        groups.set(key, [...(groups.get(key) ?? []), box]);
+    }
+    return [...groups.values()].flatMap(group => {
+        const sorted = [...group].sort((a, b) => a.y - b.y);
+        return sorted.slice(1).flatMap((next, index) => {
+            const previous = sorted[index];
+            const gap = extent(next).top - extent(previous).bottom;
+            const stacked = gap >= -EDGE_TOLERANCE && previous.x < next.x + next.width && next.x < previous.x + previous.width;
+            return stacked && !SPACING_SCALE.some(step => Math.abs(step - gap) <= EDGE_TOLERANCE)
+                ? [{ between: [previous.elementId, next.elementId], gap }]
+                : [];
+        });
+    });
+}

package/dist/knowledge/microserviceParameters.js

@@ -0,0 +1,58 @@
+/**
+ * MS-023 — tablo kaynaklı ucun ÇAĞRI PARAMETRESİ adı ve kök filtre alias'ı.
+ *
+ * Runtime kuralı (`PostgreSqlRelationHandler`): bir filtrenin alanı önce alias'tan çözülür —
+ * `GetField` alias'ı ya ANA ENTITY'nin SLUG'ıyla ya da bir join alias'ıyla eşler, başka hiçbir
+ * değeri tanımaz. Çözülen filtrenin çağrı parametresi ise `ResolveSingleField`'da
+ * `alias == mainEntity.Slug ? field.Slug : '<alias>.<field.Slug>'` olur. Tasarım zamanındaki
+ * `parameterScheme` üretimi (`Microservice.SourceEntityParameterScheme`) AYNI kuralı uygular, yani
+ * uç çağrılabilir olduğu sürece şemadaki ad runtime'ın beklediği addır.
+ *
+ * Kusur tek bir yerde doğar: kök filtrenin alias'ı entity slug'ından FARKLI verilirse
+ * (`sourceParameters.alias`'ı entity slug'ı sanmak yaygın hata) filtre runtime'da hiç çözülmez.
+ * Zorunlu filtrede sonuç 400 `FilterFieldNotResolvedException`'dır ve parametre HANGİ adla
+ * gönderilirse gönderilsin değişmez; `parameterScheme` ise nitelikli adı (`kredi.id`) gösterip
+ * "adı yanlış yazmışım" izlenimi verir.
+ *
+ * Ölçüm 2026-09-20 (`rehber-basit/tb119-get`, entity slug `tb119_urun`):
+ *   alias 'u'          → parameterScheme 'u.kod' · çağrı 400 FilterFieldNotResolvedException
+ *   alias 'tb119_urun' → parameterScheme 'kod'   · çağrı 200
+ *
+ * Bu yüzden gateway adı YENİDEN ADLANDIRMAZ (çalışmayan bir ucu çalışıyormuş gibi gösterirdi);
+ * çözülmeyen alias'ı işaretler ve düzeltince parametrenin hangi ad olacağını söyler.
+ */
+function collectJoinAliases(joins, into) {
+    for (const join of Array.isArray(joins) ? joins : []) {
+        if (!join || typeof join !== 'object')
+            continue;
+        const record = join;
+        if (typeof record.alias === 'string' && record.alias !== '')
+            into.add(record.alias);
+        collectJoinAliases(record.joins, into);
+    }
+}
+export function unresolvedParameterAliases(definition) {
+    if (String(definition.source ?? '') !== 'table')
+        return [];
+    const sourceParameters = (definition.sourceParameters ?? {});
+    const joinAliases = new Set();
+    collectJoinAliases(sourceParameters.joins, joinAliases);
+    const scheme = Array.isArray(definition.parameterScheme) ? definition.parameterScheme : [];
+    return scheme
+        .map(entry => String(entry?.name ?? ''))
+        .filter(name => name.includes('.'))
+        .map(name => ({ name, alias: name.slice(0, name.indexOf('.')), field: name.slice(name.indexOf('.') + 1) }))
+        .filter(entry => entry.alias !== '' && !joinAliases.has(entry.alias));
+}
+export function parameterAliasWarning(entries, entitySlug) {
+    if (entries.length === 0)
+        return undefined;
+    const lines = entries.map(entry => `'${entry.name}' (alias '${entry.alias}')`);
+    const target = entitySlug === undefined
+        ? "entity'nin SLUG'ı (entity_get ile okuyun; sourceParameters.alias DEĞİL)"
+        : `'${entitySlug}'`;
+    return `MS-023 — bu ucun ${lines.join(' · ')} parametresi runtime'da ÇÖZÜLMEZ: nitelikli adın alias'ı ne bir join alias'ı ne de entity slug'ı. `
+        + `Kök filtrenin alias'ı ${target} olmak zorundadır (PostgreSqlRelationHandler.GetField); bu hâliyle zorunlu filtre 400 FilterFieldNotResolvedException verir ve parametreyi HANGİ adla gönderirseniz gönderin sonuç değişmez. `
+        + `Alias düzeltilince çağrı parametresi nitelenmemiş alan slug'ı olur: ${entries.map(entry => `'${entry.field}'`).join(' · ')}. `
+        + "Düzeltme: microservice_patch { op: 'replace', path: '/sourceParameters/filters/<i>/alias', value: '<entity slug>' }. Ölçüldü 2026-09-20.";
+}

package/dist/knowledge/mining.js

@@ -0,0 +1,94 @@
+/**
+ * b-91 süreç madenciliği dışa aktarımının gateway tarafı denetimi. Resmî IEEE XES XSD'si ve OCEL 2.0
+ * JSON şeması için doğrulayıcı kütüphane (libxml, ajv) paket onayı ister; bu yüzden denetim
+ * **yapısaldır** ve yanıtta `validation: 'structural'` diye adlandırılır — dış aracın açıp
+ * açmayacağının kanıtı değildir, bozuk ya da eksik dosyayı ilk elden yakalar.
+ */
+const maxProblems = 20;
+/** ISO 8601 tarih-saat; `Date.parse` tek başına '1' gibi değerleri de tarih sayar */
+const isIsoTimestamp = (value) => !!value && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:?\d{2})$/.test(value) && !Number.isNaN(Date.parse(value));
+/**
+ * XES: kök `log` ve `xes.version`, her iz `trace` en az bir `concept:name` taşır, her olayda
+ * `concept:name` ve ayrıştırılabilir `time:timestamp` vardır.
+ */
+export function checkXes(xml) {
+    const problems = [];
+    const root = /^\s*(?:<\?xml[^>]*\?>\s*)?(?:<!--[\s\S]*?-->\s*)*<log\b([^>]*)>/.exec(xml);
+    if (!root)
+        problems.push("kök öğe 'log' değil");
+    else if (!/\bxes\.version="[^"]+"/.test(root[1] ?? ''))
+        problems.push("'log' öğesinde xes.version yok");
+    const traces = [...xml.matchAll(/<trace\b[^>]*>([\s\S]*?)<\/trace>/g)];
+    let eventCount = 0;
+    traces.forEach((trace, traceIndex) => {
+        const body = trace[1] ?? '';
+        const events = [...body.matchAll(/<event\b[^>]*>([\s\S]*?)<\/event>/g)];
+        const traceAttributes = body.replace(/<event\b[^>]*>[\s\S]*?<\/event>/g, '');
+        const topLevelAttributes = traceAttributes.replace(/<(string|date|int|float|boolean|id|list|container)\b[^>]*[^/]>[\s\S]*?<\/\1>/g, '');
+        if (!/<string\b[^>]*key="concept:name"/.test(topLevelAttributes))
+            problems.push(`iz ${traceIndex + 1}: concept:name yok`);
+        events.forEach((event, eventIndex) => {
+            const eventBody = event[1] ?? '';
+            const timestamp = /<date\b[^>]*key="time:timestamp"[^>]*value="([^"]*)"/.exec(eventBody)?.[1];
+            eventCount++;
+            if (!/key="concept:name"/.test(eventBody))
+                problems.push(`iz ${traceIndex + 1} olay ${eventIndex + 1}: concept:name yok`);
+            if (!isIsoTimestamp(timestamp))
+                problems.push(`iz ${traceIndex + 1} olay ${eventIndex + 1}: time:timestamp yok ya da tarih değil`);
+        });
+    });
+    return { validated: problems.length === 0, validation: 'structural', problems: problems.slice(0, maxProblems), traceCount: traces.length, eventCount };
+}
+/**
+ * OCEL 2.0 JSON: dört dizi var; her nesne ve olay türü bildirilmiş; olay zamanı tarih; her
+ * ilişki var olan bir nesneye bakar.
+ */
+export function checkOcel(text) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return { validated: false, validation: 'structural', problems: ['JSON ayrıştırılamadı'], objectCount: 0, eventCount: 0 };
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        return { validated: false, validation: 'structural', problems: ['kök değer nesne değil'], objectCount: 0, eventCount: 0 };
+    }
+    const log = parsed;
+    const problems = [];
+    for (const key of ['objectTypes', 'eventTypes', 'objects', 'events']) {
+        if (!Array.isArray(log[key]))
+            problems.push(`'${key}' dizisi yok`);
+    }
+    const entries = (value, name) => {
+        const list = Array.isArray(value) ? value : [];
+        const invalid = list.filter(entry => !entry || typeof entry !== 'object').length;
+        if (invalid > 0)
+            problems.push(`'${name}' içinde nesne olmayan ${invalid} kayıt`);
+        return list.filter(entry => entry && typeof entry === 'object');
+    };
+    const objects = entries(log.objects, 'objects');
+    const events = entries(log.events, 'events');
+    const objectTypes = new Set(entries(log.objectTypes, 'objectTypes').map(objectType => objectType.name));
+    const eventTypes = new Set(entries(log.eventTypes, 'eventTypes').map(eventType => eventType.name));
+    const objectIds = new Set(objects.map(ocelObject => ocelObject.id));
+    for (const ocelObject of objects) {
+        if (!objectTypes.has(ocelObject.type))
+            problems.push(`nesne ${ocelObject.id}: tür '${ocelObject.type}' objectTypes'ta yok`);
+        for (const relationship of ocelObject.relationships ?? []) {
+            if (!objectIds.has(relationship.objectId))
+                problems.push(`nesne ${ocelObject.id}: ilişki '${relationship.objectId}' nesnelerde yok`);
+        }
+    }
+    for (const event of events) {
+        if (!eventTypes.has(event.type))
+            problems.push(`olay ${event.id}: tür '${event.type}' eventTypes'ta yok`);
+        if (!isIsoTimestamp(event.time))
+            problems.push(`olay ${event.id}: time ISO 8601 tarih-saat değil`);
+        for (const relationship of event.relationships ?? []) {
+            if (!objectIds.has(relationship.objectId))
+                problems.push(`olay ${event.id}: ilişki '${relationship.objectId}' nesnelerde yok`);
+        }
+    }
+    return { validated: problems.length === 0, validation: 'structural', problems: problems.slice(0, maxProblems), objectCount: objects.length, eventCount: events.length };
+}