@appaflytech/zeyrek-ai-mcp 0.0.22 → 0.0.24

package/dist/knowledge/rules.js

@@ -137,11 +137,14 @@ export function readsBeforeGuard(source, root) {
  * code.ts:49). Eşleşme yoksa flow-engine.ts:79 sessizce durur. Studio tarafında da zincir
  * `sourceBranch === 'always'` ile çizilir (EventActionsStart.svelte:47, EventActionsItem.svelte:298).
  * condition dalları rule id'sidir (serbest), microservice'te 'success' yalnız eski şema için
- * yaşatılır (microservice.ts:144).
+ * yaşatılır (microservice.ts:174 `isHasSuccess`). 'error' dalı 2026-09-26'dan beri motorun
+ * KENDİSİ tanır (ADR 0004, ZM-07/g-02): bağlıysa hata anında `always` hiç koşmaz, sürer
+ * (microservice.ts:182 `hasBranch`) — eski motor tanımadığı dalı hiç aramadığı için bu ekleme
+ * geriye dönük zararsızdır.
  */
 const flowBranchNames = {
     start: ['always'],
-    microservice: ['always', 'success'],
+    microservice: ['always', 'success', 'error'],
     confirm: ['yes', 'no', 'always'],
     function: ['always'],
     end: []
@@ -154,7 +157,7 @@ const flowBranchNames = {
  */
 export const knownFlowStepTypes = new Set([
     'start', 'end', 'query', 'setter', 'download', 'condition', 'redirect', 'setcookie', 'alert', 'confirm',
-    'microservice', 'validation', 'flow-trigger', 'storage', 'navigate', 'code', 'function'
+    'microservice', 'validation', 'flow-trigger', 'storage', 'navigate', 'code', 'function', 'share'
 ]);
 const flowFreeBranchTypes = new Set(['condition']);
 /** `condition.types.ts` ConditionArgumentRuleType — motorun tanıdığı üçlü. */
@@ -167,7 +170,8 @@ const conditionRuleIdPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}
 // Runtime.svelte'de HAM verilir (`argument: step.args`), yani bu alanlarda ifade değerlendirilmez.
 const flowLiteralTextFields = new Map([
     ['alert', ['message', 'description']],
-    ['confirm', ['message', 'title', 'confirmText', 'cancelText']]
+    ['confirm', ['message', 'title', 'confirmText', 'cancelText']],
+    ['share', ['title']]
 ]);
 const flowExpressionLooking = /\$\{|\b(?:Steps|Page|Row|Widget|LocalStorage|state|self|item|event|error|cookie)\s*(?:\?\.|\.|\[)/;
 // Barındırıcıya özel tipler BURADA kural üretmez. `navigate`i gateway normalizasyonu zaten
@@ -294,25 +298,71 @@ function writesRolesWithoutSlug(entityId, parameters) {
 }
 const rolesSlugMessage = "Built-in 'roles' entity'sine slug YAZMADAN rol satırı ÜRETİLİYOR (operation create/upsert). Insert 200 döner, satır role_list'te görünür ve page.roleIds ile bağlanır — ama yetkilendirme SLUG karşılaştırır: platformun get-user sorgusu roles+user_roles join'inden slug dizisi üretir ve Authorized(user.roles) o rol için hiçbir zaman tutmaz. fields'a slug'ı ekleyin ('super-admin' slug'ını vermeyin — platform süper yöneticiyi o slug ile arar). Upsert'te slug'ı İFADEYLE üretmeyin: UPDATE yolunda ifade yeniden değerlendirilir ve var olan rolün slug'ı sessizce değişir (MS-016) — üretilen slug'ı yalnız create ucunda yazın. Rolü kullanıcıya bağlamak ayrı bir user_roles satırıdır.";
 const contractKeys = ['returnDtoId', 'parameterDtoId', 'returnBehavior', 'parameterBehavior'];
-const filterOperators = new Set(['eq', 'neq', 'lt', 'lte', 'gt', 'gte', 'contains', 'icontains', 'in', 'notin', 'startswith', 'endswith', 'istartswith', 'iendswith', 'isnull', 'isnotnull']);
+/**
+ * Filtre işleci sözlüğü — backend `OperatorType` enum'u (paketlenmiş `Filter` şeması; eşitliği
+ * `test/filter-operators.test.ts` kilitler). Studio filtre ARAYÜZÜNÜN sözlüğü (`notContains`, `between`…,
+ * `componentCatalog.ts`) ayrı bir kavramdır: arayüz onları bu işleçlere çevirir.
+ */
+export const filterOperators = new Set(['eq', 'neq', 'lt', 'lte', 'gt', 'gte', 'contains', 'icontains', 'in', 'notin', 'startswith', 'endswith', 'istartswith', 'iendswith', 'isnull', 'isnotnull']);
+/** Ajanların sık yazdığı yanlış adlar → doğru işleç. Yalnız ÖNERİLİR, sessizce çevrilmez. */
+const filterOperatorSuggestions = {
+    ne: 'neq', '!=': 'neq', '<>': 'neq', noteq: 'neq', notequal: 'neq', notequals: 'neq', not_eq: 'neq',
+    '=': 'eq', '==': 'eq', equal: 'eq', equals: 'eq',
+    '<': 'lt', '<=': 'lte', '>': 'gt', '>=': 'gte',
+    like: 'contains', ilike: 'icontains', nin: 'notin', 'not in': 'notin', not_in: 'notin'
+};
 function flattenFilterTree(filters) {
     return filters
         .filter((filter) => Boolean(filter) && typeof filter === 'object')
         .flatMap(filter => [filter, ...flattenFilterTree(asArray(filter.children))]);
 }
+/**
+ * Bilinmeyen işleçler, öneriyle: `status: 'ne' (neq mı demek istedin?)`. Grup çocukları da okunur. Ad
+ * büyük/küçük harfe DUYARLI eşlenir — backend de öyle eşler (`GetValueFromDescription` `==`); `NEQ`
+ * bilinmeyendir ve küçük harfli adı önerilir.
+ */
+function unknownFilterOperators(filters) {
+    return flattenFilterTree(filters)
+        .filter(filter => filter.operator !== undefined && filter.operator !== null && !filterOperators.has(String(filter.operator)))
+        .map(filter => {
+        const operator = String(filter.operator);
+        const lower = operator.toLowerCase();
+        const suggestion = filterOperators.has(lower) ? lower : filterOperatorSuggestions[lower];
+        return `${String(filter.fieldSlug ?? filter.fieldId ?? '?')}: '${operator}'${suggestion ? ` (${suggestion} mı demek istedin?)` : ''}`;
+    });
+}
+const unknownOperatorConsequence = "Bilinmeyen işleç yola ve backend sürümüne göre ya 400 alır ya sessizce 'eq'e düşer ve sorgu yanlış sonuç döner (2026-09-27'den sonraki backend uç çağrısının `filters` parametresini 400 ile reddeder; workflow tablo adımı hâlâ sessizce 'eq' yapar); ad büyük/küçük harfe duyarlıdır — doğru işleci yazın";
 function unknownOperatorFindings(ruleId, owner, filters) {
-    const unknownOperators = flattenFilterTree(filters)
-        .filter(filter => filter.operator !== undefined && filter.operator !== null && !filterOperators.has(String(filter.operator).toLowerCase()))
-        .map(filter => `${String(filter.fieldSlug ?? filter.fieldId ?? '?')}: '${String(filter.operator)}'`);
+    const unknownOperators = unknownFilterOperators(filters);
     return unknownOperators.length > 0
         ? [{
                 ruleId,
                 severity: 'block',
-                message: `${owner}: bilinmeyen filtre operatörü — ${unknownOperators.join(', ')}. Platform bilinmeyen operatörü 400 ile REDDETMEZ, sessizce 'eq'e düşürür (EnumExtensions.GetValueFromDescription null → default) ve uç testten geçip yanlış çalışır. Geçerli sözlük: ${[...filterOperators].join(' · ')} ('like' yok — metin araması için 'contains'/'icontains').`,
+                message: `${owner}: bilinmeyen filtre işleci — ${unknownOperators.join(', ')}. ${unknownOperatorConsequence}. Geçerli sözlük: ${[...filterOperators].join(' · ')} ('like' yok — metin araması için 'contains'/'icontains').`,
                 guide: 'ngapps://guides/microservice'
             }]
         : [];
 }
+/**
+ * Çalışma anında gelen filtre (`row_list.filters`, `microservice_execute` `filters` parametresi): dizi ya
+ * da JSON dizesi. Bilinmeyen işleç varsa hata METNİ döner — araç isteği göndermeden 400 verir
+ * (plans/mobil-plantcare-acigi g-03). Ayrıştırılamayan değer backend'e bırakılır.
+ */
+export function filterOperatorError(owner, filters) {
+    let parsed = filters;
+    if (typeof filters === 'string') {
+        try {
+            parsed = JSON.parse(filters);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    const unknownOperators = Array.isArray(parsed) ? unknownFilterOperators(parsed) : [];
+    return unknownOperators.length > 0
+        ? `${owner}: bilinmeyen filtre işleci — ${unknownOperators.join(', ')}. İstek GÖNDERİLMEDİ. ${unknownOperatorConsequence}. Geçerli sözlük: ${[...filterOperators].join(' · ')}.`
+        : undefined;
+}
 function isReadOperation(parameters) {
     const operation = String(parameters?.operation ?? '').toLowerCase();
     return !writeOperations.has(operation);
@@ -2365,7 +2415,7 @@ export const policyRules = [
         id: 'FLOW-022',
         module: 'flow',
         appliesTo: ['create', 'update'],
-        sourceRef: "alert.ts `const { message, alertType, description } = task.argument` → toast.error(message, { description }) / dialog.alert(message); confirm.ts `dialog.confirm(message, { title, confirmText, cancelText })` (boş çerçeve metni dialog.functions.ts resolveDialogFrame'de sabit metne düşer). Argüman Runtime.svelte'de HAM geçer (`argument: step.args`) — bu alanlarda hiçbir ifade değerlendirilmez, yazılan metin ekranda harfi harfine görünür (2026-09-06·2 koşusu S-13'ün ikinci turu: rehber hata mesajını göstermek için alert adımını öneriyordu)",
+        sourceRef: "alert.ts `const { message, alertType, description } = task.argument` → toast.error(message, { description }) / dialog.alert(message); confirm.ts `dialog.confirm(message, { title, confirmText, cancelText })` (boş çerçeve metni dialog.functions.ts resolveDialogFrame'de sabit metne düşer). Argüman Runtime.svelte'de HAM geçer (`argument: step.args`) — bu alanlarda hiçbir ifade değerlendirilmez, yazılan metin ekranda harfi harfine görünür (2026-09-06·2 koşusu S-13'ün ikinci turu: rehber hata mesajını göstermek için alert adımını öneriyordu). share adımında (2026-09-25) yalnız `title` düz metindir: @ng-apps/flow resolveShareContent onu olduğu gibi verir, `message` ve `path` ifadedir",
         check: definition => flowAllSteps(definition)
             .flatMap((step) => {
             const type = String(step.type ?? '');
@@ -2378,11 +2428,56 @@ export const policyRules = [
                 .map(field => ({
                 ruleId: 'FLOW-022',
                 severity: 'warn',
-                message: `'${flowStepLabel(step)}' ${type} adımının '${field}' alanı ifade içeriyor ama bu alan DÜZ METİNDİR: ${type}.ts task.argument.${field}'i doğrudan ekrana geçirir ve args hiçbir yerde değerlendirilmez (Runtime.svelte \`argument: step.args\`). Kullanıcı ifadenin sonucunu değil ifadenin KENDİSİNİ görür. Ucun mesajını göstermek için bir setter (ya da code) adımı kullanın — value { type: 'code', ref: 'Steps.error?.message' }; hata metninin nerede durduğu page.md §hata yolu'nda.`,
+                message: type === 'share'
+                    ? `'${flowStepLabel(step)}' share adımının '${field}' alanı ifade içeriyor ama bu alan DÜZ METİNDİR: başlık paylaşım penceresine olduğu gibi gider (iOS'ta e-posta konusu, Android'de seçici başlığı), ifade değerlendirilmez. Değişen içeriği ifade olan 'message' alanına yazın — ör. message: "'Şuna bak: ' + Page.properties.name"; bağlantı 'path' alanındadır.`
+                    : `'${flowStepLabel(step)}' ${type} adımının '${field}' alanı ifade içeriyor ama bu alan DÜZ METİNDİR: ${type}.ts task.argument.${field}'i doğrudan ekrana geçirir ve args hiçbir yerde değerlendirilmez (Runtime.svelte \`argument: step.args\`). Kullanıcı ifadenin sonucunu değil ifadenin KENDİSİNİ görür. Ucun mesajını göstermek için bir setter (ya da code) adımı kullanın — value { type: 'code', ref: 'Steps.error?.message' }; hata metninin nerede durduğu page.md §hata yolu'nda.`,
                 guide: 'ngapps://guides/page'
             }));
         })
     },
+    {
+        id: 'FLOW-027',
+        module: 'flow',
+        appliesTo: ['create', 'update'],
+        sourceRef: "share adımının argümanı StepManagementArgument'ın Title/Message/Path alanlarında saklanır (StepType.cs `share`, kök docs/adr/0001-share-akis-adimi.md); url/link/text gibi anahtarlar sözleşmede YOKTUR ve platform onları 200 ile sessizce düşürür — adım hiçbir şey paylaşmadan akış sürer. `message` ve `path` İFADEDİR (@ng-apps/flow resolveShareContent → runCode): tırnaksız 'https://…' JS'te etiket + yorumdur, undefined döner",
+        check: definition => flowAllSteps(definition)
+            .filter(step => step.type === 'share')
+            .flatMap((step) => {
+            const args = (step.args ?? {});
+            const filled = (key) => typeof args[key] === 'string' && String(args[key]).trim().length > 0;
+            const findings = [];
+            const strayLinks = ['url', 'link', 'href'].filter(filled);
+            const strayTexts = ['text', 'body', 'content'].filter(filled);
+            if (strayLinks.length > 0) {
+                findings.push({
+                    ruleId: 'FLOW-027',
+                    severity: filled('path') ? 'warn' : 'block',
+                    message: `'${flowStepLabel(step)}' share adımının bağlantısı args.${strayLinks.join('/args.')} alanında: bu anahtar StepManagementArgument sözleşmesinde YOK, platform onu 200 ile sessizce düşürür ve adım bağlantısız kalır. Bağlantıyı args.path'e ifade olarak yazın — ör. "'https://ornek.app/urun/' + Page.queryParams.id".`,
+                    guide: 'ngapps://guides/page'
+                });
+            }
+            if (strayTexts.length > 0) {
+                findings.push({
+                    ruleId: 'FLOW-027',
+                    severity: filled('message') ? 'warn' : 'block',
+                    message: `'${flowStepLabel(step)}' share adımının metni args.${strayTexts.join('/args.')} alanında: bu anahtar StepManagementArgument sözleşmesinde YOK, platform onu sessizce düşürür. Metni args.message'a ifade olarak yazın — ör. "'Şuna bak: ' + Page.properties.name".`,
+                    guide: 'ngapps://guides/page'
+                });
+            }
+            for (const key of ['message', 'path']) {
+                const value = typeof args[key] === 'string' ? String(args[key]).trim() : '';
+                if (/^[a-z][a-z\d+\-.]*:\/\//i.test(value)) {
+                    findings.push({
+                        ruleId: 'FLOW-027',
+                        severity: 'block',
+                        message: `'${flowStepLabel(step)}' share adımının '${key}' alanı tırnaksız bir adres: '${value}'. Bu alan İFADEDİR — tırnaksız adres JS'te etiket + yorumdur, undefined döner ve hiçbir şey paylaşılmaz. Dize olarak yazın: "'${value}'".`,
+                        guide: 'ngapps://guides/page'
+                    });
+                }
+            }
+            return findings;
+        })
+    },
     {
         id: 'FLOW-023',
         module: 'flow',

package/dist/knowledge/styleResolve.js

@@ -154,6 +154,24 @@ const resolveShadow = (shadow) => {
         return undefined;
     return SHADOW_VALUES[shadow] ?? String(shadow);
 };
+/**
+ * Döndür / ölçekle / kaydır alanlarının kabul aralığı — frontend `style-groups/transform-fields.ts`
+ * `TRANSFORM_RANGES`'in kopyası (altın vakalar kilitler). Aralık dışı ve birimli değer yazılmaz.
+ */
+export const TRANSFORM_RANGES = {
+    rotate: [-360, 360],
+    scale: [10, 500],
+    translateX: [-1000, 1000],
+    translateY: [-1000, 1000]
+};
+/** Sayı ya da sayısal metin, aralığın içinde; aksi `undefined` — frontend `transformValue`. */
+export const transformValue = (value, field) => {
+    if (typeof value !== 'number' && (typeof value !== 'string' || value.trim() === ''))
+        return undefined;
+    const parsed = Number(value);
+    const [min, max] = TRANSFORM_RANGES[field];
+    return Number.isFinite(parsed) && parsed >= min && parsed <= max ? parsed : undefined;
+};
 /**
  * Grupların alan listeleri — frontend `style-groups/style-group-schemas.ts`
  * `STYLE_GROUP_FIELDS`'in kopyası. Parite testi `components.json`'daki gerçek
@@ -170,7 +188,11 @@ export const STYLE_GROUP_FIELDS = {
         'borderLeft',
         'shadow',
         'contentOverflow',
-        'opacity'
+        'opacity',
+        'rotate',
+        'scale',
+        'translateX',
+        'translateY'
     ],
     typographyStyle: [
         'textColor',
@@ -220,6 +242,21 @@ export function composeTypedStyle(input, ext) {
         if (opacity !== undefined && opacity >= 0 && opacity < 100) {
             groups.opacity = String(opacity / 100);
         }
+        // Döndür / ölçekle / kaydır (ADR 0005): kaydır → döndür → ölçekle, köken merkez;
+        // ölçek yüzdedir, nötr değer ve aralık dışı yazılmaz — frontend `composeSurfaceTransform`.
+        const transform = [];
+        const x = transformValue(surface.translateX, 'translateX') ?? 0;
+        const y = transformValue(surface.translateY, 'translateY') ?? 0;
+        if (x !== 0 || y !== 0)
+            transform.push(`translate(${x}px, ${y}px)`);
+        const rotate = transformValue(surface.rotate, 'rotate');
+        if (rotate !== undefined && rotate !== 0)
+            transform.push(`rotate(${rotate}deg)`);
+        const scale = transformValue(surface.scale, 'scale');
+        if (scale !== undefined && scale !== 100)
+            transform.push(`scale(${scale / 100})`);
+        if (transform.length)
+            groups.transform = transform.join(' ');
         // `ROOT_TARGET` (`&`) kökün kendisidir: kendi derleyicisi olmayan kaplarda
         // yüzey düğüm kutusuna yazılır ve kaydırılan da odur.
         if (isSet(surface.contentOverflow) && ext?.overflowTarget) {
@@ -251,8 +288,10 @@ export function composeTypedStyle(input, ext) {
         assign(rules, 'borderColor', hover.borderColor);
         assign(rules, 'boxShadow', resolveShadow(hover.shadow));
         const lift = asDimension(hover.lift);
-        if (lift !== undefined)
-            rules.transform = `translateY(calc(-1 * ${lift}))`;
+        // Kaldırma düğümün kendi transform'unu ezmez, önüne eklenir.
+        if (lift !== undefined) {
+            rules.transform = `translateY(calc(-1 * ${lift}))${typeof groups.transform === 'string' ? ` ${groups.transform}` : ''}`;
+        }
         if (Object.keys(rules).length) {
             const duration = asNumber(hover.transitionMs) ?? 160;
             groups.transition = `background-color ${duration}ms ease, border-color ${duration}ms ease, box-shadow ${duration}ms ease, transform ${duration}ms ease`;
@@ -500,6 +539,13 @@ export const NODE_SURFACE_TYPES = new Set([
     'qm-sidebar',
     'auth-layout'
 ]);
+/**
+ * `style`'ı kendi içeriğinin CSS'i olarak alan tipler: `html`in `style`'ı uzun metindir ve yazarın
+ * işaretlemesine kapsamlı girer — web'de emotion sınıfı (`html.functions.ts` `resolveHtmlStyleClass`),
+ * mobilde korumalı belgenin stil bloğu (plans/mobil-plantcare-acigi f-20). "Düz CSS string style"
+ * (PAGE-014) ve "ham CSS çizilmez" (MOB-002) uyarıları bu tiplerde yanlıştır.
+ */
+export const DOCUMENT_STYLE_TYPES = new Set(['html']);
 const NODE_SURFACE_EXTENSION = { overflowTarget: ROOT_TARGET };
 /** Düğüm kutusuna inen yüzey; kap tipi değilse ya da grup boşsa yok. */
 export function composeNodeSurfaceStyle(type, surfaceStyle) {

package/dist/knowledge/styleResolveNative.js

@@ -1,4 +1,4 @@
-import { rawProp } from './styleResolve.js';
+import { TRANSFORM_RANGES, rawProp, transformValue } from './styleResolve.js';
 import { mergeTypeScale, resolveTheme } from './themeResolve.js';
 /* ---- css-value.ts ---- */
 const warn = (context, message) => {
@@ -45,6 +45,46 @@ export function parseFontFamily(value) {
     const first = String(value).split(',')[0].trim().replace(/^["']|["']$/g, '');
     return first || null;
 }
+const GENERIC_FONT_FAMILIES = new Set([
+    'serif', 'sans-serif', 'monospace', 'cursive', 'fantasy', 'system-ui',
+    'ui-serif', 'ui-sans-serif', 'ui-monospace', 'ui-rounded', 'emoji', 'math', 'fangsong'
+]);
+/** CSS generik ailesi mi (`sans-serif`, `monospace`…) — tırnaklanırsa aile adı sanılır. */
+export function isGenericFontFamily(name) {
+    return GENERIC_FONT_FAMILIES.has(name.trim().toLowerCase());
+}
+/**
+ * Yığının yedek generiği: son generik ad, yoksa `sans-serif`. Temanın yığını `"Figtree",
+ * sans-serif` biçimindedir; tek ad yazılan `typographyStyle` yedeğini buradan miras alır (ZM-10).
+ */
+export function fontFallback(stack) {
+    const generic = String(stack ?? '').split(',').map(part => part.trim().replace(/^["']|["']$/g, '')).filter(isGenericFontFamily).pop();
+    return generic ?? 'sans-serif';
+}
+/** Yığının yalın ilk adı (tırnaksız); yükleyicinin istediği ad budur (ZM-10, f-05). */
+export function firstFontFamily(value) {
+    return parseFontFamily(value) ?? '';
+}
+/**
+ * Font adı platforma göre çözülür (ZM-10, K3). Frontend'de bu WEB/cihaz diye ikiye ayrılır
+ * (`font-family.ts` / `font-family.native.ts`, Metro `.native`'i seçer) ama bu ayna TEK koldur:
+ * `test/style-resolve-native.test.ts` frontend'in `theme-native.ts`'ini düz Node `import()` ile
+ * okur ve Node/Vite çözümü platform uzantısını (`.native.ts`) hiç görmez — parite testinin
+ * kıyasladığı gerçek davranış bu yüzden HER ZAMAN web kolu (`font-family.ts`); cihazdaki yalın-ad
+ * davranışı yalnız Metro bundle'ında oluşur ve bu aynanın kapsamı dışındadır (g-02 parity fix).
+ * Tek ad generik yedeksiz kalırsa RN web'de font yüklenemediğinde tarayıcı varsayılanı (Times)
+ * çizilir; bu yüzden tek ad tırnaklanıp temanın generiğiyle yığına çevrilir, yazarın kendi yığını
+ * (virgüllü) aynen geçer.
+ */
+export function resolveFontFamily(value, fallback) {
+    const text = value.trim();
+    if (text === '' || text.includes(','))
+        return text;
+    const name = firstFontFamily(text);
+    if (isGenericFontFamily(name))
+        return name;
+    return `"${name}", ${fallback}`;
+}
 export function parseLineHeight(value, fontSize, context) {
     if (value === undefined || value === null || value === '')
         return null;
@@ -202,6 +242,9 @@ export function resolveThemeNative(theme, mode = 'light') {
         if (narrow)
             scale[`${level}Mobile`] = px(narrow, fontSize);
     }
+    const bodyStack = vars['--ng-font'] ?? tokens.fontFamily;
+    const headingStack = vars['--ng-font-heading'] ?? bodyStack;
+    const fallback = fontFallback(bodyStack);
     return {
         mode,
         vars,
@@ -214,8 +257,11 @@ export function resolveThemeNative(theme, mode = 'light') {
             pill: px(vars['--ng-radius-pill'], 999)
         },
         font: {
-            family: vars['--ng-font'] ?? tokens.fontFamily,
-            headingFamily: vars['--ng-font-heading'] ?? tokens.fontFamily,
+            family: resolveFontFamily(bodyStack, fallback),
+            headingFamily: resolveFontFamily(headingStack, fallback),
+            source: firstFontFamily(bodyStack),
+            headingSource: firstFontFamily(headingStack),
+            fallback,
             size: fontSize,
             weight: vars['--ng-font-weight'] ?? tokens.fontWeight,
             scale
@@ -302,6 +348,55 @@ const composeBorders = (surface, shell, theme, context) => {
             shell.borderStyle = style;
     }
 };
+/** Yüzey grubunun bilinen alanları; kalanı uyarıya yazılır (frontend `SURFACE_KEYS`). MOB-002 de buradan okur. */
+export const SURFACE_KEYS = new Set([
+    'background',
+    'radius',
+    'borderTop',
+    'borderRight',
+    'borderBottom',
+    'borderLeft',
+    'shadow',
+    'contentOverflow',
+    'opacity',
+    'rotate',
+    'scale',
+    'translateX',
+    'translateY',
+    'borderWidth',
+    'borderStyle',
+    'borderColor'
+]);
+/**
+ * Döndür / ölçekle / kaydır (ADR 0005): web ile aynı sıra ve aralık, RN dizisi. Dolu ama geçersiz
+ * değer (birimli metin, aralık dışı) uyarıya yazılır — frontend `composeTransform`.
+ */
+const composeTransform = (surface, shell, warnings) => {
+    const read = (field) => {
+        const raw = surface[field];
+        if (!isSet(raw))
+            return undefined;
+        const value = transformValue(raw, field);
+        if (value === undefined) {
+            const [min, max] = TRANSFORM_RANGES[field];
+            warnings?.push(`surfaceStyle.${field}: ${String(raw)} geçersiz — ${min}…${max} arası sayı, atlandı`);
+        }
+        return value;
+    };
+    const transform = [];
+    const x = read('translateX') ?? 0;
+    const y = read('translateY') ?? 0;
+    if (x !== 0 || y !== 0)
+        transform.push({ translateX: x }, { translateY: y });
+    const rotate = read('rotate');
+    if (rotate !== undefined && rotate !== 0)
+        transform.push({ rotate: `${rotate}deg` });
+    const scale = read('scale');
+    if (scale !== undefined && scale !== 100)
+        transform.push({ scale: scale / 100 });
+    if (transform.length)
+        shell.transform = transform;
+};
 const composeSurface = (surface, shell, theme, context) => {
     const background = asText(surface.background, theme);
     if (background)
@@ -325,12 +420,17 @@ const composeSurface = (surface, shell, theme, context) => {
         if (overflow === 'auto')
             context.warnings?.push('contentOverflow: auto — RN kaydırmayı bileşenin kendisi açar, kutu hidden yapıldı');
     }
+    composeTransform(surface, shell, context.warnings);
+    for (const [key, value] of Object.entries(surface)) {
+        if (!SURFACE_KEYS.has(key) && isSet(value))
+            context.warnings?.push(`surfaceStyle.${key}: mobilde karşılığı yok, atlandı`);
+    }
 };
 const composeTypography = (typography, text, theme, context) => {
     const color = asText(typography.textColor, theme);
     if (color)
         text.color = color;
-    const family = parseFontFamily(asText(typography.fontFamily, theme));
+    const family = resolveFontFamily(asText(typography.fontFamily, theme) ?? '', theme.font.fallback);
     if (family)
         text.fontFamily = family;
     const fontSize = parsePanelLength(typeof typography.fontSize === 'string' ? resolveThemeToken(typography.fontSize, theme) : typography.fontSize, context);

package/dist/observability/trace.js

@@ -351,7 +351,7 @@ export function logGatewayEvent(message) {
  */
 export function logCapabilityGap(gap) {
     const lines = [
-        `┌─ ${clockOf(new Date())} · KABİLİYET BOŞLUĞU · ${gap.severity}${gap.module ? ` · ${gap.module}` : ''}`,
+        `┌─ ${clockOf(new Date())} · KABİLİYET BOŞLUĞU · ${gap.severity}${gap.module ? ` · ${gap.module}` : ''}${gap.project ? ` · proje ${gap.project}` : ''}`,
         `│  hedef  : ${condense(gap.goal, maxBodyChars)}`,
         `│  engel  : ${condense(gap.blocker, maxBodyChars)}`
     ];

package/dist/platform/argumentAliases.js

@@ -0,0 +1,128 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { PlatformApiError } from './errors.js';
+import { RefResolver, isGuid } from './refs.js';
+const text = (value) => typeof value === 'string' ? value : String(value ?? '');
+const hostAlias = (from, host) => ({
+    tool: '*',
+    from,
+    when: (shape, args) => 'host' in shape && 'hostId' in shape && !(from in shape) && args.host === undefined && args.hostId === undefined,
+    apply: async (value) => ({ set: { host, hostId: value }, note: `${from} → host: '${host}', hostId: ${text(value)}` })
+});
+export const ARGUMENT_ALIASES = [
+    hostAlias('pageId', 'page'),
+    hostAlias('layoutId', 'layout'),
+    hostAlias('componentId', 'component'),
+    {
+        tool: '*',
+        from: 'project',
+        when: (shape, args) => 'projectId' in shape && !('project' in shape) && args.projectId === undefined,
+        apply: async (value, _args, { platform }) => {
+            if (isGuid(text(value)))
+                return { set: { projectId: text(value) }, note: `project → projectId: ${text(value)}` };
+            // Önce slug (`/p/{slug}`), sonra ad: liste arama sonucunda slug ya da ad birebir (büyük/küçük harf duyarsız).
+            const bySlug = await platform.org('GET', `/p/${encodeURIComponent(text(value))}`).catch(() => undefined);
+            const wanted = text(value).toLocaleLowerCase('tr');
+            const listed = bySlug?.data?.id
+                ? undefined
+                : await platform.org('GET', '/projects', { query: { searchTerm: text(value), pageLength: 50 } }).catch(() => undefined);
+            const projectId = bySlug?.data?.id ?? listed?.data?.find(project => [project.slug, project.name].some(candidate => candidate?.toLocaleLowerCase('tr') === wanted))?.id;
+            if (!projectId)
+                throw new PlatformApiError(`'${text(value)}' diye bir proje yok (slug ya da ad); projectId'yi project_list ile bulun.`, 400);
+            return { set: { projectId }, note: `project '${text(value)}' → projectId: ${projectId}` };
+        }
+    },
+    {
+        tool: '*',
+        from: 'id',
+        when: (shape, args) => 'microservice' in shape && 'application' in shape && !('id' in shape) && args.microservice === undefined,
+        apply: async (value, args, { platform }) => {
+            if (!isGuid(text(value)))
+                return { set: { microservice: text(value) }, note: `id → microservice: '${text(value)}'` };
+            if (typeof args.application !== 'string')
+                throw new PlatformApiError("id bir microservice GUID'i; slug'ını çözmek için 'application' (uygulama slug'ı) da verin.", 400);
+            const resolver = new RefResolver(platform, args.project, args.environment);
+            const applicationId = await resolver.applicationId(args.application);
+            const payload = await platform.tenant('GET', args.project, `/microservices/${applicationId}/${text(value)}`, { environment: args.environment });
+            const slug = payload?.data?.slug;
+            if (!slug)
+                throw new PlatformApiError(`'${args.application}' uygulamasında ${text(value)} id'li microservice yok; microservice_list ile slug'ı bulun.`, 400);
+            return { set: { microservice: slug }, note: `id ${text(value)} → microservice: '${slug}'` };
+        }
+    },
+    {
+        tool: 'entity_get',
+        from: 'applicationId',
+        apply: async (value, args, { platform }) => {
+            const project = args.project;
+            const environment = args.environment;
+            const resolver = new RefResolver(platform, project, environment);
+            const applicationId = await resolver.applicationId(text(value));
+            const entity = await resolver.entity(text(args.id));
+            const payload = await platform.tenant('GET', project, `/entities/${entity.datasourceId}/${entity.entityId}`, { environment });
+            const linked = (payload?.data?.applications ?? []).some(link => [link.id, link.applicationId].some(id => id?.toLowerCase() === applicationId.toLowerCase()));
+            if (!linked) {
+                throw new PlatformApiError(`'${text(args.id)}' entity'si '${text(value)}' uygulamasına bağlı değil; entity_get uygulamaya göre değil entity'ye göre çalışır — applicationId'yi kaldırın ya da uygulamanın entity'lerini entity_list {applicationId} ile listeleyin.`, 400);
+            }
+            return { set: { datasourceId: entity.datasourceId }, note: `applicationId '${text(value)}' → datasourceId: ${entity.datasourceId} (entity '${text(args.id)}' bu uygulamaya bağlı)` };
+        }
+    },
+    {
+        tool: '*',
+        from: 'applicationId',
+        when: (shape, args) => shape.applicationId !== undefined && typeof args.applicationId === 'string' && !shape.applicationId.safeParse(args.applicationId).success,
+        apply: async (value, args, { platform }) => {
+            const applicationId = await new RefResolver(platform, args.project, args.environment).applicationId(text(value));
+            return { set: { applicationId }, note: `applicationId '${text(value)}' → ${applicationId}` };
+        }
+    }
+];
+export async function applyArgumentAliases(tool, args, context) {
+    if (!args || typeof args !== 'object' || Array.isArray(args))
+        return { args, applied: [] };
+    let current = { ...args };
+    const applied = [];
+    for (const alias of ARGUMENT_ALIASES) {
+        if (alias.tool !== '*' && alias.tool !== tool)
+            continue;
+        if (!(alias.from in current))
+            continue;
+        if (!(alias.when ? alias.when(context.shape, current) : !(alias.from in context.shape)))
+            continue;
+        const outcome = await alias.apply(current[alias.from], current, context);
+        const { [alias.from]: _replaced, ...rest } = current;
+        current = { ...rest, ...outcome.set };
+        applied.push(outcome.note);
+    }
+    return { args: current, applied };
+}
+/**
+ * Takma adı olmayan bilinmeyen argüman için "bunu mu demek istedin": okunan alanlar arasından büyük/küçük
+ * harf duyarsız düzenleme uzaklığı 2'yi geçmeyen en yakın ad (`hostID` → `hostId`, `views` → `view`).
+ */
+export function closestArgument(key, accepted) {
+    const distance = (left, right) => {
+        const row = Array.from({ length: right.length + 1 }, (_, index) => index);
+        for (let i = 1; i <= left.length; i++) {
+            let diagonal = row[0] ?? 0;
+            row[0] = i;
+            for (let j = 1; j <= right.length; j++) {
+                const above = row[j] ?? 0;
+                row[j] = Math.min(above + 1, (row[j - 1] ?? 0) + 1, diagonal + (left[i - 1] === right[j - 1] ? 0 : 1));
+                diagonal = above;
+            }
+        }
+        return row[right.length] ?? 0;
+    };
+    const ranked = accepted
+        .map(name => ({ name, score: distance(key.toLowerCase(), name.toLowerCase()) }))
+        .filter(entry => entry.score <= 2)
+        .sort((left, right) => left.score - right.score);
+    return ranked[0]?.name;
+}
+const activeNotes = new AsyncLocalStorage();
+export function runWithArgumentNotes(notes, run) {
+    return activeNotes.run(notes, run);
+}
+export function argumentNotes() {
+    return activeNotes.getStore() ?? { aliasesApplied: [] };
+}