@appaflytech/zeyrek-ai-mcp 0.0.36 → 0.0.40

package/dist/knowledge/styleResolveNative.js

@@ -0,0 +1,529 @@
+import { TRANSFORM_RANGES, rawProp, resolveNodeStyleLayers, transformValue } from './styleResolve.js';
+import { mergeTypeScale, resolveTheme } from './themeResolve.js';
+/* ---- css-value.ts ---- */
+const warn = (context, message) => {
+    context?.warnings?.push(message);
+    return null;
+};
+export function parseLength(value, context) {
+    if (value === undefined || value === null || value === '')
+        return null;
+    if (typeof value === 'number')
+        return Number.isFinite(value) ? value : null;
+    const text = String(value).trim();
+    if (!text)
+        return null;
+    const numeric = Number(text);
+    if (Number.isFinite(numeric))
+        return numeric;
+    if (text.endsWith('%')) {
+        const percent = Number(text.slice(0, -1));
+        return Number.isFinite(percent) ? `${percent}%` : null;
+    }
+    const unit = /^(-?[\d.]+)(px|em|rem)$/.exec(text);
+    if (unit) {
+        const amount = Number(unit[1]);
+        if (!Number.isFinite(amount))
+            return null;
+        if (unit[2] === 'px')
+            return amount;
+        const base = unit[2] === 'em' ? context?.base ?? context?.root : context?.root;
+        if (base === undefined)
+            return warn(context, `${text}: em/rem tabanı yok, değer atlandı`);
+        return Math.round(amount * base * 1000) / 1000;
+    }
+    return warn(context, `${text}: React Native'de karşılığı olmayan uzunluk`);
+}
+export function parsePanelLength(value, context) {
+    if (typeof value === 'number' && value === 0)
+        return null;
+    return parseLength(value, context);
+}
+export function parseFontFamily(value) {
+    if (value === undefined || value === null || value === '')
+        return null;
+    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;
+    const text = String(value).trim();
+    const numeric = Number(text);
+    const base = fontSize ?? context?.base ?? context?.root;
+    if (Number.isFinite(numeric)) {
+        if (numeric <= 0)
+            return null;
+        const ratio = numeric >= 4 ? numeric / 100 : numeric;
+        if (base === undefined)
+            return warn(context, `lineHeight ${text}: punto bilinmiyor, atlandı`);
+        return Math.round(ratio * base * 1000) / 1000;
+    }
+    if (text.endsWith('%')) {
+        const percent = Number(text.slice(0, -1));
+        if (!Number.isFinite(percent) || base === undefined)
+            return warn(context, `lineHeight ${text}: punto bilinmiyor, atlandı`);
+        return Math.round((percent / 100) * base * 1000) / 1000;
+    }
+    const length = parseLength(text, context);
+    return typeof length === 'number' ? length : null;
+}
+export function parseOpacity(value) {
+    if (value === undefined || value === null || value === '')
+        return null;
+    const amount = Number(value);
+    if (!Number.isFinite(amount) || amount < 0 || amount >= 100)
+        return null;
+    return Math.round((amount / 100) * 1000) / 1000;
+}
+export function parseBorderShorthand(value, context) {
+    if (value === undefined || value === null || value === '')
+        return null;
+    const text = String(value).trim();
+    if (!text || text === 'none')
+        return { width: 0, style: 'solid' };
+    const parts = text.split(/\s+(?![^(]*\))/);
+    const width = parseLength(parts[0], context);
+    if (typeof width !== 'number')
+        return warn(context, `${text}: kenarlık genişliği çözülemedi`);
+    const style = parts.find(part => /^(solid|dashed|dotted)$/.test(part)) ?? 'solid';
+    const color = parts.find(part => part !== parts[0] && !/^(solid|dashed|dotted)$/.test(part));
+    return { width, style, ...(color ? { color } : {}) };
+}
+/* ---- theme-native.ts ---- */
+const camelize = (name) => name.replace(/^--ng-/, '').replace(/-([a-z0-9])/g, (_, character) => character.toUpperCase());
+const hexToRgb = (hex) => {
+    const match = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(hex.trim());
+    if (!match)
+        return null;
+    const digits = match[1].length === 3 ? match[1].split('').map(digit => digit + digit).join('') : match[1];
+    const value = parseInt(digits, 16);
+    return [(value >> 16) & 255, (value >> 8) & 255, value & 255];
+};
+const toHex = (channel) => Math.round(Math.max(0, Math.min(255, channel))).toString(16).padStart(2, '0');
+const NAMED_COLORS = { white: '#ffffff', black: '#000000' };
+const resolveColorMix = (value) => {
+    const match = /^color-mix\(\s*in\s+srgb\s*,\s*([^,]+?)\s+([\d.]+)%\s*,\s*([^)]+?)\s*\)$/i.exec(value.trim());
+    if (!match)
+        return value;
+    const [, rawFrom = '', percent = '0', rawTo = ''] = match;
+    const from = hexToRgb(NAMED_COLORS[rawFrom.trim()] ?? rawFrom);
+    const to = hexToRgb(NAMED_COLORS[rawTo.trim()] ?? rawTo);
+    if (!from || !to)
+        return rawFrom.trim();
+    const weight = Number(percent) / 100;
+    const mixed = from.map((channel, index) => channel * weight + to[index] * (1 - weight));
+    return `#${mixed.map(toHex).join('')}`;
+};
+const CALC_UNIT = /^(-?[\d.]+)([a-z%]*)$/;
+const evaluateCalc = (value) => {
+    let result = value;
+    while (true) {
+        const match = /calc\(([^()]*)\)/.exec(result);
+        if (!match)
+            return result;
+        const [left, operator = '', right] = match[1].trim().split(/\s+/);
+        const leftParts = CALC_UNIT.exec(left ?? '');
+        const rightAmount = Number(right);
+        if (!leftParts || !Number.isFinite(rightAmount) || !'*/'.includes(operator)) {
+            result = result.replace(match[0], match[1].trim());
+            return result;
+        }
+        const amount = operator === '*' ? Number(leftParts[1]) * rightAmount : Number(leftParts[1]) / rightAmount;
+        result = result.replace(match[0], `${Math.round(amount * 1000) / 1000}${leftParts[2]}`);
+    }
+};
+const resolveVars = (raw) => {
+    const resolved = {};
+    const expand = (value, seen) => {
+        const expanded = value.replace(/var\((--[a-z0-9-]+)(?:\s*,\s*([^)]+))?\)/g, (whole, name, fallback) => {
+            if (seen.has(name))
+                return whole;
+            const target = raw[name];
+            if (target === undefined)
+                return fallback?.trim() ?? whole;
+            return expand(target, new Set([...seen, name]));
+        });
+        return resolveColorMix(evaluateCalc(expanded));
+    };
+    for (const [name, value] of Object.entries(raw))
+        resolved[name] = expand(value, new Set([name]));
+    return resolved;
+};
+const px = (value, fallback) => {
+    if (!value)
+        return fallback;
+    const amount = Number(String(value).replace(/px$/, ''));
+    return Number.isFinite(amount) ? amount : fallback;
+};
+export function parseShadow(css) {
+    if (!css || css === 'none')
+        return {};
+    const color = /rgba?\(([^)]+)\)/.exec(css);
+    const lengths = css.replace(/rgba?\([^)]+\)/, '').trim().split(/\s+/)
+        .map(part => Number(part.replace(/px$/, '')))
+        .filter(part => Number.isFinite(part));
+    const [offsetX = 0, offsetY = 0, blur = 0] = lengths;
+    const channels = color?.[1].split(',').map(part => Number(part.trim())) ?? [];
+    const [red = 0, green = 0, blue = 0, alpha = 1] = channels;
+    return {
+        shadowColor: `#${toHex(red)}${toHex(green)}${toHex(blue)}`,
+        shadowOffset: { width: offsetX, height: offsetY },
+        shadowOpacity: alpha,
+        shadowRadius: blur,
+        elevation: Math.round(blur / 2)
+    };
+}
+/**
+ * Proje temasının mobil karşılığı. Frontend `resolveThemeNative(overrides, mode = 'light')` ile
+ * aynı: mod çağırandan gelir, temanın kendi `mode` alanı okunmaz (runtime da okumuyor).
+ */
+export function resolveThemeNative(theme, mode = 'light') {
+    const resolvedTheme = resolveTheme(theme, mode);
+    const vars = resolveVars(resolvedTheme.cssVars);
+    const tokens = resolvedTheme.tokens;
+    const colors = {};
+    for (const [name, value] of Object.entries(vars)) {
+        if (/^(#|rgb|hsl)/.test(value))
+            colors[camelize(name)] = value;
+    }
+    const fontSize = px(vars['--ng-font-size'], 14);
+    const spacingBase = px(vars['--ng-spacing'], 10);
+    const spacing = { base: spacingBase };
+    for (const [name, value] of Object.entries(vars)) {
+        const level = /^--ng-spacing-([a-z]+)$/.exec(name);
+        if (level)
+            spacing[level[1]] = px(value, spacingBase);
+    }
+    const scale = {};
+    for (const level of Object.keys(mergeTypeScale(tokens.typeScale))) {
+        scale[level] = px(vars[`--ng-font-size-${level}`], fontSize);
+        const narrow = vars[`--ng-font-size-${level}-mobile`];
+        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,
+        colors,
+        spacing,
+        radius: {
+            sm: px(vars['--ng-radius-sm'], 2),
+            md: px(vars['--ng-radius-md'], 4),
+            lg: px(vars['--ng-radius-lg'], 12),
+            pill: px(vars['--ng-radius-pill'], 999)
+        },
+        font: {
+            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
+        },
+        shadow: {
+            none: {},
+            sm: parseShadow(vars['--ng-shadow-sm']),
+            md: parseShadow(vars['--ng-shadow-md']),
+            lg: parseShadow(vars['--ng-shadow-lg'])
+        }
+    };
+}
+/* ---- compose-native-style.ts ---- */
+const TEXT_KEYS = new Set(['color', 'fontFamily', 'fontSize', 'fontStyle', 'fontWeight', 'letterSpacing', 'lineHeight', 'textAlign', 'textDecorationLine', 'textTransform']);
+const RENAMED_KEYS = { background: 'backgroundColor', textDecoration: 'textDecorationLine' };
+const IGNORED_KEYS = new Set(['boxShadow', 'transition', 'cursor', 'boxSizing', 'whiteSpace', 'wordBreak', 'textOverflow', 'backdropFilter', 'filter']);
+const isPlainObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const isSet = (value) => value !== undefined && value !== null && value !== '' && !(typeof value === 'string' && value.includes('{{'));
+export function resolveThemeToken(value, theme) {
+    return value.replace(/var\((--[a-z0-9-]+)(?:\s*,\s*([^)]+))?\)/g, (whole, name, fallback) => theme.vars[name] ?? fallback?.trim() ?? whole);
+}
+const UNRESOLVED_TOKEN = /var\(\s*(--[a-z0-9-]+)\s*\)/;
+/** Frontend `compose-native-style.ts` `asText` aynası: çözülemeyen yedeksiz jeton yazılmaz, uyarıya düşer (K37-c). */
+const asText = (value, theme, warnings, field) => {
+    if (!isSet(value))
+        return undefined;
+    const resolved = resolveThemeToken(String(value), theme);
+    const unresolved = UNRESOLVED_TOKEN.exec(resolved);
+    if (!unresolved)
+        return resolved;
+    warnings?.push(`${field ?? 'değer'}: tanımsız tema jetonu ${unresolved[1]}, atlandı`);
+    return undefined;
+};
+const composeRadius = (value, shell, theme, context) => {
+    if (!isSet(value))
+        return;
+    const preset = theme.radius[String(value)];
+    if (preset !== undefined) {
+        shell.borderRadius = preset;
+        return;
+    }
+    const parts = resolveThemeToken(String(value), theme).trim().split(/\s+/);
+    if (parts.length === 1) {
+        const radius = parsePanelLength(parts[0], context);
+        if (typeof radius === 'number')
+            shell.borderRadius = radius;
+        return;
+    }
+    const corners = ['borderTopLeftRadius', 'borderTopRightRadius', 'borderBottomRightRadius', 'borderBottomLeftRadius'];
+    corners.forEach((corner, index) => {
+        const radius = parseLength(parts[index] ?? parts[index % parts.length], context);
+        if (typeof radius === 'number')
+            shell[corner] = radius;
+    });
+};
+const composeBorders = (surface, shell, theme, context) => {
+    const sides = [
+        ['borderTop', 'borderTopWidth', 'borderTopColor'],
+        ['borderRight', 'borderRightWidth', 'borderRightColor'],
+        ['borderBottom', 'borderBottomWidth', 'borderBottomColor'],
+        ['borderLeft', 'borderLeftWidth', 'borderLeftColor']
+    ];
+    let wrote = false;
+    for (const [field, widthKey, colorKey] of sides) {
+        if (!isSet(surface[field]))
+            continue;
+        const border = parseBorderShorthand(resolveThemeToken(String(surface[field]), theme), context);
+        if (!border)
+            continue;
+        wrote = true;
+        shell[widthKey] = border.width;
+        if (border.color)
+            shell[colorKey] = border.color;
+        if (border.style !== 'solid' && !shell.borderStyle)
+            shell.borderStyle = border.style;
+    }
+    if (wrote)
+        return;
+    const width = Number(surface.borderWidth);
+    const color = asText(surface.borderColor, theme, context.warnings, 'surfaceStyle.borderColor');
+    const style = asText(surface.borderStyle, theme);
+    if (Number.isFinite(width) && isSet(surface.borderWidth)) {
+        shell.borderWidth = width;
+        if (width > 0) {
+            shell.borderColor = color ?? theme.colors.borderPrimary;
+            if (style && style !== 'solid')
+                shell.borderStyle = style;
+        }
+        return;
+    }
+    if (color || style) {
+        shell.borderWidth = 1;
+        shell.borderColor = color ?? theme.colors.borderPrimary;
+        if (style && style !== 'solid')
+            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, context.warnings, 'surfaceStyle.background');
+    if (background)
+        shell.backgroundColor = background;
+    composeRadius(surface.radius, shell, theme, context);
+    composeBorders(surface, shell, theme, context);
+    if (isSet(surface.shadow) && isSet(surface.background) && !background) {
+        context.warnings?.push('surfaceStyle.shadow: zemin çözülemedi, gölge çocuklara düşerdi — atlandı');
+    }
+    else if (isSet(surface.shadow)) {
+        const raw = String(surface.shadow);
+        const key = raw;
+        if (!theme.shadow[key] && (raw.includes(',') || raw.includes('inset'))) {
+            context.warnings?.push(`shadow: RN tek katman taşır, ilk katman uygulandı (${raw})`);
+        }
+        Object.assign(shell, theme.shadow[key] ?? parseShadow(resolveThemeToken(raw, theme)));
+    }
+    const opacity = parseOpacity(surface.opacity);
+    if (opacity !== null)
+        shell.opacity = opacity;
+    if (isSet(surface.contentOverflow)) {
+        const overflow = String(surface.contentOverflow);
+        shell.overflow = overflow === 'visible' ? 'visible' : 'hidden';
+        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, context.warnings, 'typographyStyle.textColor');
+    if (color)
+        text.color = color;
+    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);
+    if (typeof fontSize === 'number')
+        text.fontSize = fontSize;
+    if (isSet(typography.fontWeight))
+        text.fontWeight = String(typography.fontWeight);
+    if (isSet(typography.fontStyle))
+        text.fontStyle = String(typography.fontStyle);
+    if (isSet(typography.textDecoration))
+        text.textDecorationLine = String(typography.textDecoration);
+    if (isSet(typography.textAlign)) {
+        const align = String(typography.textAlign);
+        text.textAlign = align === 'start' ? 'left' : align === 'end' ? 'right' : align;
+    }
+    const letterSpacing = parsePanelLength(typography.letterSpacing, context);
+    if (typeof letterSpacing === 'number')
+        text.letterSpacing = letterSpacing;
+    const lineHeight = parseLineHeight(typography.lineHeight, text.fontSize ?? context.base, context);
+    if (lineHeight !== null)
+        text.lineHeight = lineHeight;
+};
+const composeFreeStyle = (value, shell, text, theme, context) => {
+    if (!isPlainObject(value))
+        return;
+    for (const [rawKey, rawValue] of Object.entries(value)) {
+        if (!isSet(rawValue))
+            continue;
+        if (rawKey.startsWith('&') || rawKey.startsWith('--') || rawKey.startsWith(':')) {
+            context.warnings?.push(`${rawKey}: RN'de alt seçici yok, atlandı`);
+            continue;
+        }
+        const key = RENAMED_KEYS[rawKey] ?? rawKey;
+        if (IGNORED_KEYS.has(key))
+            continue;
+        const target = TEXT_KEYS.has(key) ? text : shell;
+        const resolved = typeof rawValue === 'string' ? resolveThemeToken(rawValue, theme) : rawValue;
+        if (typeof resolved === 'number') {
+            target[key] = resolved;
+            continue;
+        }
+        const length = key === 'fontWeight' || typeof resolved !== 'string' ? null : parseLength(resolved, { ...context, warnings: undefined });
+        target[key] = length ?? resolved;
+    }
+};
+export function composeNativeStyle(input, theme) {
+    const warnings = [];
+    const shell = {};
+    const text = {};
+    const context = { base: theme.font.size, root: theme.font.size, warnings };
+    composeFreeStyle(input.themeStyle, shell, text, theme, context);
+    if (isPlainObject(input.surfaceStyle))
+        composeSurface(input.surfaceStyle, shell, theme, context);
+    if (isPlainObject(input.typographyStyle))
+        composeTypography(input.typographyStyle, text, theme, context);
+    if (isPlainObject(input.hoverStyle) && Object.values(input.hoverStyle).some(isSet)) {
+        warnings.push('hoverStyle: dokunmatikte hover durumu yok, atlandı');
+    }
+    composeFreeStyle(input.style, shell, text, theme, context);
+    return { shell, text, warnings };
+}
+/**
+ * Bir düğümün mobil çizerdeki stili (`NativeRenderer` → `nativeNodeStyle`, `renderer.functions.ts`). Temanın katmanı
+ * (`componentStyles[tip]` ← `$preset`) web'in çözücüsünden gelir ve TABANDIR; panel grupları üstüne, düğümün serbest
+ * `style`'ı son söz; `$preset` işareti RN stiline inmez (plans/mobil-plantcare-acigi f-16 — 2026-09-28'e dek çizer bu
+ * katmanı okumuyordu, rapor da okumuyordu). İfadeye bağlı prop çalışma anında çözülür, burada yok.
+ */
+export function nodeNativeStyle(node, theme, source) {
+    const props = node.props;
+    const group = (name) => {
+        const value = rawProp(props, name);
+        return isPlainObject(value) ? value : null;
+    };
+    const layers = resolveNodeStyleLayers(rawProp(props, 'style'), source, node.type);
+    return composeNativeStyle({
+        themeStyle: layers.theme,
+        surfaceStyle: group('surfaceStyle'),
+        typographyStyle: group('typographyStyle'),
+        hoverStyle: group('hoverStyle'),
+        style: layers.own
+    }, theme);
+}

package/dist/knowledge/themeResolve.js

@@ -332,8 +332,8 @@ export function buildSpacingScaleVars(scale) {
         .join('\n\t');
 }
 /**
- * Bir seviyenin mobil karşılığının masaüstüne oranı — bugünkü breakpoint değerlerinden türer.
- * Kullanıcı tek çarpan ayarlar, mobil ona orantılı hareket eder.
+ * Bir seviyenin dar ekran karşılığının masaüstüne oranı — bugünkü breakpoint değerlerinden türer.
+ * Kullanıcı tek çarpan ayarlar, dar ekran ona orantılı hareket eder.
  */
 const TYPE_SCALE_MOBILE_RATIO = {
     h1: 1.7 / 2.25,
@@ -363,7 +363,7 @@ export function mergeTypeScale(overrides) {
     }
     return result;
 }
-/** Ölçekten `--ng-font-size-*` değişkenlerini üretir (masaüstü + mobil). */
+/** Ölçekten `--ng-font-size-*` değişkenlerini üretir (masaüstü + dar ekran). */
 export function buildTypeScaleVars(scale) {
     const lines = [];
     for (const [level, factor] of Object.entries(scale)) {

package/dist/observability/trace.js

@@ -1,7 +1,7 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { appendFileSync, existsSync, mkdirSync } from 'node:fs';
 import { dirname, join } from 'node:path';
-import { secretKeyPattern } from '../platform/secrets.js';
+import { maskSecretLeaf, secretKeyPattern, secretPairName } from '../platform/secrets.js';
 const defaultDirectory = join(process.cwd(), 'logs');
 const activeTrace = new AsyncLocalStorage();
 const activeRequest = new AsyncLocalStorage();
@@ -37,11 +37,16 @@ function clip(text, limit) {
 function redact(value, depth = 0) {
     if (depth > 8)
         return '…';
+    // Günlük, yanıt maskesinin gördüğü ad/değer çiftini ve yaprak jetonu da görmeli: debug gövdesi ve
+    // `asUser` argümanı buraya ham gelir (g-01, 37 S-24).
+    if (typeof value === 'string')
+        return maskSecretLeaf(value);
     if (Array.isArray(value))
         return value.map(entry => redact(entry, depth + 1));
     if (value && typeof value === 'object') {
+        const pairName = secretPairName(value);
         return Object.fromEntries(Object.entries(value).map(([key, entry]) => {
-            if (secretKeyPattern.test(key))
+            if (secretKeyPattern.test(key === 'value' && pairName !== undefined ? pairName : key))
                 return [key, '***'];
             if (/^stack(Trace)?$/i.test(key) && typeof entry === 'string') {
                 return [key, `${clip(entry.split(/\r?\n/)[0] ?? '', 240)} … (kalan stack kırpıldı)`];
@@ -204,9 +209,12 @@ function describeResult(result) {
     const text = Array.isArray(call?.content)
         ? call.content.filter(entry => entry.type === 'text').map(entry => String(entry.text)).join(' ')
         : '';
-    if (call?.isError)
-        return { ok: false, summary: clip(text, 400) };
     const structured = call?.structuredContent;
+    if (call?.isError) {
+        return structured?.expectedFailure === true
+            ? { ok: true, summary: `beklenen platform hatası (negatif test): ${clip(text, 400)}` }
+            : { ok: false, summary: clip(text, 400) };
+    }
     const runtimeErrors = structured?.runtimeErrors;
     if (Array.isArray(runtimeErrors) && runtimeErrors.length > 0) {
         // Kasıtlı negatif test bir kusur değil bir KANIT: çağıran beklediğini söylediyse satır
@@ -351,7 +359,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)}`
     ];