@appaflytech/zeyrek-ai-mcp 0.0.9 → 0.0.11

package/dist/knowledge/themeDiscover.js

@@ -0,0 +1,884 @@
+import { GOOGLE_FONTS, MAX_PRESET_VERSIONS, PALETTE_GROUPS, RADIUS_SCALE_DEFAULTS, SPACING_SCALE_DEFAULTS, TOKENS, TYPE_SCALE_DEFAULTS, isValidPresetName } from './themeResolve.js';
+import { SNAPSHOT_HINT_IGNORE } from './designSnapshot.js';
+import { componentKnowledge } from './componentCatalog.js';
+import { PlatformApiError } from '../platform/errors.js';
+import { secretKeyPattern } from '../platform/secrets.js';
+const RATIO_TOLERANCE = 0.05;
+const FULL_ROUND_PX = 999;
+const FAMILY_ALIASES = { gray: 'grey' };
+const RAMP_PREFIX_WORDS = ['color', 'colors', 'colour', 'colours', 'palette'];
+const TEXT_WORDS = ['text', 'foreground', 'fg', 'font', 'fonts'];
+const BACKGROUND_WORDS = ['background', 'backgrounds', 'bg'];
+const BORDER_WORDS = ['border', 'borders', 'stroke', 'strokes', 'divider', 'outline'];
+const STATUS_WORDS = {
+    success: 'success', positive: 'success',
+    warning: 'warning', caution: 'warning',
+    error: 'error', danger: 'error', destructive: 'error', negative: 'error',
+    info: 'info'
+};
+const ACCENT_WORDS = ['primary', 'brand', 'accent', 'hover', 'muted', 'subtle', 'tint'];
+/** Grubun VARSAYILAN anahtarını gösteren kelimeler; bunlar niteleyici sayılmaz. */
+const BASE_WORDS = ['primary', 'default', 'base', 'main'];
+/** Grup → [anahtar, o anahtarı seçen kelimeler] öncelik sırasıyla; ilk eşleşen kazanır. */
+const GROUP_KEYS = {
+    text: [['secondary', ['secondary', 'muted', 'subdued']], ['disabled', ['disabled']]],
+    background: [
+        ['inverse', ['inverse']],
+        ['overlay', ['overlay', 'backdrop', 'scrim']],
+        ['readonly', ['readonly']],
+        ['disabled', ['disabled']],
+        ['surfaceAlt', ['alt', 'secondary', 'subtle', 'muted']],
+        ['surface', ['surface', 'card']],
+        ['canvas', ['canvas', 'page', 'app', 'body']]
+    ],
+    border: [['secondary', ['secondary', 'strong']]],
+    accent: [['hover', ['hover']], ['muted', ['muted', 'soft']], ['subtle', ['subtle', 'tint', 'light']]]
+};
+const GROUP_DEFAULT_KEY = { text: 'primary', background: 'canvas', border: 'primary', accent: 'primary' };
+/** Grubu seçen kelimeler (niteleyici sayılmaz). `surface`/`card`/`overlay`… hem grup hem anahtar kelimesidir. */
+const GROUP_WORDS = {
+    text: TEXT_WORDS,
+    background: [...BACKGROUND_WORDS, 'canvas', 'page', 'surface', 'card', 'overlay', 'backdrop', 'scrim'],
+    border: BORDER_WORDS,
+    status: ['status', 'state', ...Object.keys(STATUS_WORDS)],
+    accent: ACCENT_WORDS
+};
+const TYPOGRAPHY_WORDS = ['font', 'family', 'typography', 'weight'];
+const SPACING_WORDS = ['spacing', 'space', 'gap', 'padding', 'inset'];
+const RADIUS_WORDS = ['radius', 'rounded', 'corner', 'round'];
+const LEVEL_WORDS = {
+    xs: 'xs', sm: 'sm', small: 'sm', md: 'md', medium: 'md', base: 'md', default: 'md',
+    lg: 'lg', large: 'lg', xl: 'xl', pill: 'pill', full: 'pill'
+};
+const ROLE_WORDS = {
+    h1: 'h1', display: 'h1', title: 'h1',
+    h2: 'h2', h3: 'h3', h4: 'h4',
+    label: 'label', overline: 'label',
+    body: 'p', p: 'p', paragraph: 'p', base: 'p', regular: 'p',
+    small: 'small', caption: 'small', helper: 'small', footnote: 'small'
+};
+const SHADOW_PICK_WORDS = ['md', 'medium', 'default', 'card'];
+/** Referans kademe önceliği — `md` yokken taban bu kademenin varsayılan oranından türetilir (B-9). */
+const REFERENCE_LEVELS = ['sm', 'lg', 'xs', 'xl'];
+/**
+ * Koyu palet türetme oranları (g-06): accent açık tonlara, muted/subtle koyu zemine çekilir;
+ * status renkleri hafif açılır. text/background/border türetilmez — platformun DARK_PALETTE'i
+ * zaten koyu moda göre ayarlıdır.
+ */
+const DERIVE_DARK = {
+    'accent.primary': { toward: 255, ratio: 0.35 },
+    'accent.hover': { toward: 255, ratio: 0.45 },
+    'accent.muted': { toward: 0, ratio: 0.55 },
+    'accent.subtle': { toward: 0, ratio: 0.7 },
+    'status.info': { toward: 255, ratio: 0.2 },
+    'status.success': { toward: 255, ratio: 0.2 },
+    'status.warning': { toward: 255, ratio: 0.2 },
+    'status.error': { toward: 255, ratio: 0.2 }
+};
+const isPlainObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const words = (name) => name.toLowerCase().split(/[/\-_.\s]+/).filter(word => word !== '');
+const has = (list, candidates) => list.some(word => candidates.includes(word));
+const round2 = (value) => Math.round(value * 100) / 100;
+const nearDefault = (ratio, expected) => Math.abs(ratio - expected) <= RATIO_TOLERANCE;
+const kebab = (key) => key.replace(/[A-Z]/g, letter => `-${letter.toLowerCase()}`);
+const isTone = (word) => /^\d{2,3}$/.test(word);
+/** Adı kuraldan sapan değişkenler: `accent.onPrimary` runtime'da `--ng-text-on-accent`tir (f-08). */
+const PALETTE_VAR_ALIASES = { 'accent.onPrimary': '--ng-text-on-accent' };
+/** Palet yolu → runtime değişkeni (`buildThemeStyle`: `--ng-background-surface-alt`). */
+const paletteVar = (group, key) => PALETTE_VAR_ALIASES[`${group}.${key}`] ?? `--ng-${group}-${kebab(key)}`;
+/* ---- Değer ayrıştırma ---- */
+/**
+ * Renk → `#RRGGBB` (varsayılan) ya da `#RRGGBBAA` (`keepAlpha`, yalnız `background.overlay`:
+ * platformun kendi varsayılanı `#364b764d`, alfa orada VERİDİR — inceleme B-4).
+ */
+export function normalizeHex(value, options = {}) {
+    const text = value.trim();
+    const short = /^#([0-9a-f])([0-9a-f])([0-9a-f])$/i.exec(text);
+    if (short)
+        return { hex: `#${short[1]}${short[1]}${short[2]}${short[2]}${short[3]}${short[3]}`.toUpperCase() };
+    const full = /^#([0-9a-f]{6})$/i.exec(text);
+    if (full)
+        return { hex: `#${full[1]}`.toUpperCase() };
+    const withAlpha = /^#([0-9a-f]{6})([0-9a-f]{2})$/i.exec(text);
+    if (withAlpha) {
+        return options.keepAlpha
+            ? { hex: `#${withAlpha[1]}${withAlpha[2]}`.toUpperCase() }
+            : { hex: `#${withAlpha[1]}`.toUpperCase(), note: 'alfa kanalı düşürüldü — tema renkleri #RRGGBB (yalnız background.overlay alfa taşır)' };
+    }
+    const rgb = /^rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*([\d.]+)\s*)?\)$/i.exec(text);
+    if (rgb) {
+        const channel = (part) => Math.min(255, Number(part)).toString(16).padStart(2, '0');
+        const alpha = rgb[4] === undefined ? undefined : Number(rgb[4]);
+        const base = `#${channel(rgb[1])}${channel(rgb[2])}${channel(rgb[3])}`.toUpperCase();
+        if (alpha !== undefined && alpha < 1) {
+            return options.keepAlpha
+                ? { hex: `${base}${Math.round(alpha * 255).toString(16).padStart(2, '0').toUpperCase()}`, note: `rgba → #RRGGBBAA (alfa ${alpha})` }
+                : { hex: base, note: `rgba → hex, alfa ${alpha} düşürüldü` };
+        }
+        return { hex: base, note: 'rgb → hex' };
+    }
+    return undefined;
+}
+/** `#RRGGBB`'yi beyaza (255) ya da siyaha (0) doğru `ratio` kadar karıştırır; kanal başına yuvarlar. */
+export function mixHex(hex, toward, ratio) {
+    const channels = [1, 3, 5].map(offset => Number.parseInt(hex.slice(offset, offset + 2), 16));
+    const mixed = channels.map(channel => Math.round(channel + (toward - channel) * ratio));
+    return `#${mixed.map(channel => channel.toString(16).padStart(2, '0')).join('')}`.toUpperCase();
+}
+const hasAlpha = (value) => /^#[0-9a-f]{8}$/i.test(value.trim()) || /^rgba?\([^)]*,\s*(0?\.\d+|0)\s*\)$/i.test(value.trim());
+const looksLikeColor = (value) => typeof value === 'string' && /^\s*(#|rgba?\(|hsla?\()/i.test(value);
+function parseLength(value) {
+    if (typeof value === 'number')
+        return Number.isFinite(value) ? value : undefined;
+    const match = /^\s*(-?\d+(?:\.\d+)?)\s*(?:px)?\s*$/.exec(value);
+    return match ? Number(match[1]) : undefined;
+}
+function median(values) {
+    const sorted = [...values].sort((a, b) => a - b);
+    return sorted[Math.floor(sorted.length / 2)];
+}
+/**
+ * Rol tespiti iki adımdır: önce grup (text · background · border · status · accent), sonra anahtar.
+ * Anahtarı seçen bir kelime yoksa VARSAYILAN anahtara yalnız başka niteleyici de yoksa düşülür;
+ * `bg/error` ya da `text/on-primary` gibi tanınmayan niteleyici `unknown` döner (B-3).
+ */
+function colorRole(list) {
+    // `text/on-primary`, `on-accent`, `brand/on`: accent ÜSTÜNDEKİ metin — palette.accent.onPrimary (f-08).
+    if (has(list, ['on']) && has(list, ['primary', 'accent', 'brand'])) {
+        const unknown = list.filter(word => !['on', 'primary', 'accent', 'brand', ...TEXT_WORDS].includes(word) && !isTone(word));
+        return unknown.length > 0 ? { group: 'accent', unknown } : { group: 'accent', key: 'onPrimary' };
+    }
+    const group = has(list, TEXT_WORDS) ? 'text'
+        : has(list, GROUP_WORDS.background) ? 'background'
+            : has(list, BORDER_WORDS) ? 'border'
+                : list.some(word => STATUS_WORDS[word] !== undefined) ? 'status'
+                    : has(list, ACCENT_WORDS) ? 'accent'
+                        : undefined;
+    if (group === undefined)
+        return undefined;
+    const tone = list.find(isTone);
+    let key;
+    let keyWords = [];
+    if (group === 'status') {
+        const status = list.find(word => STATUS_WORDS[word] !== undefined);
+        key = STATUS_WORDS[status];
+        keyWords = [status];
+    }
+    else {
+        const match = GROUP_KEYS[group].find(([, candidates]) => has(list, candidates));
+        if (match) {
+            key = match[0];
+            keyWords = GROUP_KEYS[group].flatMap(([, candidates]) => candidates);
+        }
+    }
+    const known = new Set([...GROUP_WORDS[group], ...keyWords, ...BASE_WORDS]);
+    const unknown = list.filter(word => !known.has(word) && !isTone(word));
+    if (unknown.length > 0)
+        return { group, unknown };
+    return { group, key: key ?? GROUP_DEFAULT_KEY[group], ...(tone === undefined ? {} : { tone }) };
+}
+const rampFamilies = () => TOKENS.colors;
+function rampKey(family, tone) {
+    const canonical = FAMILY_ALIASES[family] ?? family;
+    const tones = rampFamilies()[canonical];
+    if (tones === undefined)
+        return undefined;
+    const key = Object.keys(tones).find(candidate => candidate === tone || candidate.replace(/\D/g, '') === tone);
+    if (key === undefined) {
+        return { family: canonical, error: `ton '${tone}' tanınmadı — '${canonical}' rampasının tonları: ${Object.keys(tones).map(k => k.replace(/\D/g, '')).join(', ')}` };
+    }
+    return { family: canonical, key };
+}
+/** `colors/blue/500` · `color-gray-200` → [aile, ton]; öneksiz `blue/500` de aynı. */
+function rampWords(list) {
+    const stripped = list.filter((word, index) => !(index === 0 && RAMP_PREFIX_WORDS.includes(word)));
+    return stripped.length === 2 && isTone(stripped[1]) ? [stripped[0], stripped[1]] : undefined;
+}
+/* ---- hints ---- */
+const HINT_FORMS = '<grup>.<anahtar> (iki kümeye de) | palette.<grup>.<anahtar> | paletteDark.<grup>.<anahtar> | colors.<aile>.<ton> | ignore';
+function parseHint(hint) {
+    if (hint === SNAPSHOT_HINT_IGNORE)
+        return { kind: 'ignore' };
+    const segments = hint.split('.').filter(segment => segment !== '');
+    const paletteKey = (group, key) => (PALETTE_GROUPS[group] ?? []).includes(key);
+    if (segments.length === 2 && paletteKey(segments[0], segments[1]))
+        return { kind: 'palette', group: segments[0], key: segments[1] };
+    if (segments.length === 3) {
+        const [root, group, key] = segments;
+        if ((root === 'palette' || root === 'paletteDark') && paletteKey(group, key))
+            return { kind: 'palette', group, key, root };
+        if (root === 'colors') {
+            const resolved = rampKey(group, key);
+            if (resolved !== undefined && 'key' in resolved)
+                return { kind: 'ramp', family: resolved.family, key: resolved.key };
+        }
+    }
+    throw new PlatformApiError(`hints: '${hint}' tanınmadı — geçerli biçimler: ${HINT_FORMS}. Palet grupları: ${Object.keys(PALETTE_GROUPS).join(', ')}; rampalar: ${Object.keys(rampFamilies()).join(', ')}.`, 400);
+}
+/** Dış API (testler ve rehber): çıplak `<grup>.<anahtar>` aydınlık palete çözülür. */
+export function resolveHintPath(hint) {
+    const parsed = parseHint(hint);
+    if (parsed.kind === 'ignore')
+        return { kind: 'ignore' };
+    if (parsed.kind === 'ramp')
+        return { kind: 'path', path: `colors.${parsed.family}.${parsed.key}` };
+    return { kind: 'path', path: `${parsed.root ?? 'palette'}.${parsed.group}.${parsed.key}` };
+}
+/* ---- Öneri kurucu ---- */
+class ThemeDraft {
+    record = {};
+    owners = new Map();
+    mapping = [];
+    unmapped = [];
+    normalized = [];
+    /** Aydınlık palete YAZILAN hex → `--ng-*` adı; preset gövdeleri buna bağlanır (K6). */
+    paletteVars = new Map();
+    set(path, value) {
+        const segments = path.split('.');
+        let cursor = this.record;
+        for (const segment of segments.slice(0, -1)) {
+            const next = cursor[segment];
+            if (!isPlainObject(next))
+                cursor[segment] = {};
+            cursor = cursor[segment];
+        }
+        cursor[segments[segments.length - 1]] = value;
+    }
+    get(path) {
+        let cursor = this.record;
+        for (const segment of path.split('.')) {
+            if (!isPlainObject(cursor))
+                return undefined;
+            cursor = cursor[segment];
+        }
+        return cursor;
+    }
+    claim(path, source) {
+        const owner = this.owners.get(path);
+        if (owner !== undefined)
+            return owner;
+        this.owners.set(path, source);
+        return undefined;
+    }
+    map(entry) {
+        this.mapping.push(entry);
+    }
+    drop(source, value, reason) {
+        this.unmapped.push({ source, value, reason });
+    }
+    color(source, raw, path, via, note) {
+        if (typeof raw !== 'string') {
+            this.drop(source, raw, 'renk değeri metin değil');
+            return;
+        }
+        const parsed = normalizeHex(raw, { keepAlpha: path.endsWith('.background.overlay') });
+        if (parsed === undefined) {
+            this.drop(source, raw, `hex değil (THEME-005): '${raw}' — '#RRGGBB' bekleniyor; hsl/ad/alias çevrilmez`);
+            return;
+        }
+        const owner = this.claim(path, source);
+        if (owner !== undefined) {
+            this.drop(source, raw, `çakışma — '${owner}' bu yolu aldı (${path}); hints ile ayırın (${HINT_FORMS})`);
+            return;
+        }
+        if (parsed.hex !== raw.trim() || parsed.note !== undefined) {
+            this.normalized.push(`${source}: '${raw}' → '${parsed.hex}'${parsed.note === undefined ? '' : ` (${parsed.note})`}`);
+        }
+        this.set(path, parsed.hex);
+        this.map({ source, value: raw, path, via, ...(note === undefined ? {} : { note }) });
+        const [root, group, key] = path.split('.');
+        if (root === 'palette' && group !== undefined && key !== undefined)
+            this.paletteVars.set(parsed.hex, paletteVar(group, key));
+    }
+    theme() {
+        for (const key of Object.keys(this.record)) {
+            const value = this.record[key];
+            if (isPlainObject(value) && Object.keys(value).length === 0)
+                delete this.record[key];
+        }
+        return this.record;
+    }
+}
+/**
+ * `get_variable_defs` tipografi değişkenini metin olarak verir:
+ * `Font(family: "Inter", style: Semi Bold, size: 12, weight: 600, lineHeight: 100, letterSpacing: 5)`.
+ * Aile, punto ve ağırlık okunur; rol adın kelimelerinden gelir (ölçüldü 2026-09-16, RFQ kiti).
+ */
+export function parseFontValue(value) {
+    if (typeof value !== 'string' || !/^\s*Font\(/.test(value))
+        return undefined;
+    const family = /family:\s*"([^"]+)"/.exec(value)?.[1];
+    if (family === undefined)
+        return undefined;
+    const size = /\bsize:\s*(\d+(?:\.\d+)?)/.exec(value)?.[1];
+    const weight = /\bweight:\s*(\d{3})/.exec(value)?.[1];
+    return { family, ...(size === undefined ? {} : { size: Number(size) }), ...(weight === undefined ? {} : { weight: Number(weight) }) };
+}
+function classify(name, value) {
+    if (looksLikeColor(value))
+        return 'color';
+    if (parseFontValue(value) !== undefined)
+        return 'typography';
+    const list = words(name);
+    if (has(list, TYPOGRAPHY_WORDS) || (has(list, ['size']) && has(list, ['font', 'text', 'type'])))
+        return 'typography';
+    if (has(list, SPACING_WORDS))
+        return 'spacing';
+    if (has(list, RADIUS_WORDS))
+        return 'radius';
+    return 'other';
+}
+function mapColorByName(draft, source, raw, root) {
+    const allWords = words(source);
+    // Figma koleksiyonları modu ad önekiyle taşır (`Light/Basic/Primary`): önek kümeyle uyuşuyorsa
+    // düşer, uyuşmuyorsa değişken yanlış kümededir — tahmin edilmez, yönlendirilir.
+    const prefixMode = allWords[0] === 'light' ? 'palette' : allWords[0] === 'dark' ? 'paletteDark' : undefined;
+    if (prefixMode !== undefined && prefixMode !== root) {
+        draft.drop(source, raw, prefixMode === 'paletteDark'
+            ? "koyu mod değişkeni ('Dark/…') aydınlık kümede — variablesDark'a taşıyın"
+            : "aydınlık mod değişkeni ('Light/…') koyu kümede — variables'a taşıyın");
+        return;
+    }
+    const list = prefixMode === undefined ? allWords : allWords.slice(1);
+    const role = colorRole(list);
+    if (role !== undefined && 'key' in role) {
+        const note = role.tone === undefined
+            ? undefined
+            : `ton '${role.tone}' düştü — rol kelimesi kazandı; rampa için rolsüz ad kullanın ('${Object.keys(rampFamilies()).slice(0, 3).join('/<ton>, ')}/<ton> …')`;
+        draft.color(source, raw, `${root}.${role.group}.${role.key}`, 'role', note);
+        return;
+    }
+    if (role !== undefined) {
+        const keys = role.group === 'status' ? Object.values(STATUS_WORDS) : [GROUP_DEFAULT_KEY[role.group], ...(GROUP_KEYS[role.group] ?? []).map(([key]) => key)];
+        draft.drop(source, raw, `'${role.group}' grubunda '${role.unknown.join('/')}' için anahtar yok — grubun anahtarları: ${[...new Set(keys)].join(' · ')}; varsayılana düşülmez, kararı hints ile verin`);
+        return;
+    }
+    const ramp = rampWords(list);
+    if (ramp !== undefined) {
+        const resolved = rampKey(ramp[0], ramp[1]);
+        if (resolved !== undefined && 'error' in resolved) {
+            draft.drop(source, raw, resolved.error);
+            return;
+        }
+        if (resolved !== undefined) {
+            if (root === 'paletteDark') {
+                draft.drop(source, raw, 'rampa moda göre ayrılmaz — colors tek kümedir; koyu kümede yalnız rol renkleri okunur');
+                return;
+            }
+            draft.color(source, raw, `colors.${resolved.family}.${resolved.key}`, 'ramp');
+            return;
+        }
+    }
+    draft.drop(source, raw, `rol tanınmadı — ad şu kelimelerden birini taşımalı: ${[...TEXT_WORDS, ...BACKGROUND_WORDS, ...BORDER_WORDS, ...Object.keys(STATUS_WORDS), ...ACCENT_WORDS].join(' · ')} ya da '<aile>/<ton>' (${Object.keys(rampFamilies()).join(', ')}); kararınızı hints ile verin`);
+}
+function levelOf(list) {
+    return list.map(word => LEVEL_WORDS[word]).find(level => level !== undefined);
+}
+function mapLengths(draft, entries, kind, gaps) {
+    const basePath = kind === 'spacing' ? 'spacing' : 'borderRadius';
+    const scalePath = kind === 'spacing' ? 'spacingScale' : 'radiusScale';
+    const defaults = kind === 'spacing' ? SPACING_SCALE_DEFAULTS : RADIUS_SCALE_DEFAULTS;
+    const levelNames = kind === 'spacing' ? 'xs · sm · md · lg · xl' : 'sm · md · lg · pill';
+    if (entries.length === 0) {
+        gaps.add(basePath);
+        return;
+    }
+    // Köşede tam yuvarlak (≥ 999 px) kademesi ne olursa olsun pill'dir; boşlukta pill kademesi yoktur (B-13).
+    const pills = [];
+    const scaled = [];
+    for (const entry of entries) {
+        const isPill = kind === 'radius' && (entry.level === 'pill' || (entry.value >= FULL_ROUND_PX && entry.level !== 'sm' && entry.level !== 'md' && entry.level !== 'lg'));
+        if (isPill)
+            pills.push(entry);
+        else if (entry.level === 'pill')
+            draft.drop(entry.source, entry.raw, `kademe 'pill' ${kind === 'spacing' ? 'spacing' : 'köşe'}'te yok — ${levelNames}`);
+        else
+            scaled.push(entry);
+    }
+    for (const entry of pills) {
+        if (entry.value >= FULL_ROUND_PX) {
+            draft.map({ source: entry.source, value: entry.raw, path: 'radiusScale.pill', via: 'variable', note: `tam yuvarlak (≥ ${FULL_ROUND_PX}px) platform varsayılanıdır, yazılmadı` });
+        }
+        else {
+            draft.set('radiusScale.pill', `${entry.value}px`);
+            draft.map({ source: entry.source, value: entry.raw, path: 'radiusScale.pill', via: 'variable' });
+        }
+    }
+    if (scaled.length === 0) {
+        gaps.add(basePath);
+        return;
+    }
+    const platformBase = parseLength(kind === 'spacing' ? TOKENS.spacing : TOKENS.borderRadius);
+    const md = scaled.find(entry => entry.level === 'md');
+    const leveled = scaled.filter(entry => entry.level !== undefined && defaults[entry.level] !== undefined);
+    const reference = md ?? REFERENCE_LEVELS.map(level => leveled.find(entry => entry.level === level)).find(entry => entry !== undefined);
+    const unleveled = scaled.filter(entry => entry.level === undefined);
+    let base;
+    let baseSource;
+    let baseNote;
+    if (md !== undefined) {
+        base = md.value;
+        baseSource = md;
+    }
+    else if (reference !== undefined) {
+        // md yokken taban kademeli girdiden TÜRETİLİR: referans kademenin oranı varsayılan sayılır (B-9).
+        const expected = defaults[reference.level];
+        base = round2(reference.value / expected);
+        baseSource = reference;
+        baseNote = `referans kademe '${reference.level}' — taban ${reference.value} / ${expected} = ${base}px olarak türetildi, bu kademenin oranı varsayılan sayıldı`;
+    }
+    else {
+        base = median(unleveled.map(entry => entry.value));
+        baseSource = unleveled.find(entry => entry.value === base);
+        baseNote = `kademe adı yok — taban ${unleveled.length} değerin medyanından (${base}px)`;
+    }
+    if (base <= 0) {
+        for (const entry of scaled)
+            draft.drop(entry.source, entry.raw, `taban ${base} — 0 ya da negatif uzunluktan oran hesaplanamaz (THEME-006/007)`);
+        return;
+    }
+    if (base !== platformBase)
+        draft.set(basePath, `${base}px`);
+    draft.map({
+        source: baseSource.source,
+        value: baseSource.raw,
+        path: md !== undefined || reference === undefined ? basePath : `${scalePath}.${baseSource.level}`,
+        via: 'variable',
+        note: baseNote ?? (base === platformBase ? `platform varsayılanına (${platformBase}px) eşit, yazılmadı` : undefined)
+    });
+    for (const entry of scaled) {
+        if (entry === baseSource)
+            continue;
+        if (entry.level === undefined) {
+            if (md === undefined && reference === undefined) {
+                draft.map({ source: entry.source, value: entry.raw, path: basePath, via: 'variable', note: 'kademe adı yok — yalnız taban medyanına katıldı' });
+            }
+            else {
+                draft.drop(entry.source, entry.raw, `kademe adı yok — ${levelNames}; taban '${baseSource.source}' oldu`);
+            }
+            continue;
+        }
+        if (entry.level === 'md') {
+            draft.drop(entry.source, entry.raw, `ikinci 'md' kademesi — taban '${baseSource.source}' oldu`);
+            continue;
+        }
+        const expected = defaults[entry.level];
+        if (expected === undefined) {
+            draft.drop(entry.source, entry.raw, `kademe '${entry.level}' temada yok — ${levelNames}`);
+            continue;
+        }
+        if (entry.value <= 0) {
+            draft.drop(entry.source, entry.raw, `${entry.value} — 0 ya da negatif kademe oran üretmez (THEME-007)`);
+            continue;
+        }
+        const ratio = round2(entry.value / base);
+        const path = `${scalePath}.${entry.level}`;
+        if (nearDefault(ratio, expected)) {
+            draft.map({ source: entry.source, value: entry.raw, path, via: 'variable', note: `oran ${ratio} varsayılana (${expected}) ±${RATIO_TOLERANCE} içinde, yazılmadı — yalnız sapan yazılır` });
+            continue;
+        }
+        draft.set(path, ratio);
+        draft.map({ source: entry.source, value: entry.raw, path, via: 'variable' });
+    }
+}
+function googleFont(name) {
+    const lower = name.trim().toLowerCase();
+    return GOOGLE_FONTS.find(font => font.toLowerCase() === lower);
+}
+const cssWeight = (value) => {
+    const text = String(value).trim().toLowerCase();
+    return /^[1-9]00$/.test(text) || text === 'normal' || text === 'bold' ? text : undefined;
+};
+function mapTypography(draft, records, gaps) {
+    const body = records.find(record => record.role === 'p');
+    const heading = records.find(record => record.role === 'h1');
+    const platformSize = parseLength(TOKENS.fontSize);
+    const families = [];
+    if (body?.family !== undefined)
+        families.push({ field: body.family, path: 'fontFamily' });
+    else
+        gaps.add('fontFamily');
+    if (heading?.family !== undefined && String(heading.family.value).trim().toLowerCase() !== String(body?.family?.value ?? '').trim().toLowerCase()) {
+        families.push({ field: heading.family, path: 'headingFontFamily' });
+    }
+    for (const { field, path } of families) {
+        const via = typeof field.raw === 'number' ? 'textStyle' : field.source === String(field.raw) ? 'textStyle' : 'variable';
+        const requested = String(field.value);
+        const listed = googleFont(requested);
+        if (listed === undefined) {
+            gaps.add(path);
+            draft.drop(field.source, field.raw, `'${requested}' panelin Google Fonts listesinde yok (THEME-008) — runtime fontu ADIYLA Google'dan çeker, tanınmayan ad sessizce sans-serif'e düşer. Listedeki bir adı anlık görüntüde düzeltin ya da alanı boş bırakın`);
+            continue;
+        }
+        if (listed !== requested.trim())
+            draft.normalized.push(`${field.source}: ${path} '${requested}' → '${listed}' (listedeki yazım)`);
+        if (path === 'fontFamily' && listed === TOKENS.fontSource) {
+            draft.map({ source: field.source, value: field.raw, path, via, note: `platform varsayılanı '${TOKENS.fontSource}', yazılmadı` });
+            continue;
+        }
+        draft.set(path, listed);
+        draft.map({ source: field.source, value: field.raw, path, via });
+    }
+    const sized = records.filter(record => record.size !== undefined);
+    if (sized.length === 0) {
+        gaps.add('typeScale');
+    }
+    else if (body?.size === undefined) {
+        gaps.add('typeScale');
+        for (const record of sized)
+            draft.drop(record.size.source, record.size.raw, "gövde (p) boyutu yok — oranlar tabana göre hesaplanır; 'p' rolünde bir metin stili ya da font/size/body değişkeni gerekir");
+    }
+    else if (body.size.value <= 0) {
+        for (const record of sized)
+            draft.drop(record.size.source, record.size.raw, `gövde boyutu ${body.size.value} — 0 ya da negatif tabandan oran hesaplanamaz (THEME-006)`);
+    }
+    else {
+        const base = body.size.value;
+        if (base !== platformSize)
+            draft.set('fontSize', `${base}px`);
+        draft.map({ source: body.size.source, value: body.size.raw, path: 'fontSize', via: 'textStyle', note: base === platformSize ? `platform varsayılanına (${platformSize}px) eşit, yazılmadı` : undefined });
+        // Platformda p tabanın 0,925'idir; Figma gövdesi tabanın KENDİSİ olduğu için p oranı 1 yazılır,
+        // yoksa 15 px gövde 13,9 px çizilir. Sapan kuralı burada da geçerli: 1 ≠ 0,925.
+        for (const record of sized) {
+            const level = record.role;
+            const size = record.size;
+            if (size.value <= 0) {
+                draft.drop(size.source, size.raw, `${size.value} — 0 ya da negatif punto oran üretmez`);
+                continue;
+            }
+            const ratio = level === 'p' ? 1 : round2(size.value / base);
+            const expected = TYPE_SCALE_DEFAULTS[level];
+            const path = `typeScale.${level}`;
+            if (nearDefault(ratio, expected)) {
+                draft.map({ source: size.source, value: size.raw, path, via: 'textStyle', note: `oran ${ratio} varsayılana (${expected}) ±${RATIO_TOLERANCE} içinde, yazılmadı` });
+                continue;
+            }
+            draft.set(path, ratio);
+            draft.map({ source: size.source, value: size.raw, path, via: 'textStyle', ...(level === 'p' ? { note: 'p oranı 1: Figma gövde boyutu tabanın kendisi (platformda p = 0,925 × taban)' } : {}) });
+        }
+    }
+    if (body?.weight !== undefined) {
+        const weight = cssWeight(body.weight.value);
+        if (weight === undefined) {
+            draft.drop(body.weight.source, body.weight.raw, `ağırlık '${String(body.weight.value)}' CSS değeri değil — 100–900 sayı ya da normal/bold; Figma stil adını ('Regular', 'Semi Bold') sayıya çevirip anlık görüntüye yazın`);
+        }
+        else {
+            if (weight !== TOKENS.fontWeight)
+                draft.set('fontWeight', weight);
+            draft.map({ source: body.weight.source, value: body.weight.raw, path: 'fontWeight', via: 'textStyle', note: weight === TOKENS.fontWeight ? `platform varsayılanına (${TOKENS.fontWeight}) eşit, yazılmadı` : undefined });
+        }
+    }
+}
+function mapShadow(draft, snapshot, gaps) {
+    const effects = snapshot.effects ?? [];
+    if (effects.length === 0) {
+        gaps.add('shadow');
+        return;
+    }
+    const byBlur = [...effects].sort((a, b) => a.blur - b.blur);
+    const chosen = effects.find(effect => has(words(effect.name), SHADOW_PICK_WORDS)) ?? byBlur[Math.floor(byBlur.length / 2)];
+    for (const effect of effects) {
+        if (effect !== chosen)
+            draft.drop(effect.name, effect.blur, `tema tek gölge tarifi taşır (sm/md/lg ondan türetilir); '${chosen.name}' seçildi`);
+    }
+    const parsed = normalizeHex(chosen.color);
+    if (parsed === undefined) {
+        draft.drop(chosen.name, chosen.color, `gölge rengi hex değil (THEME-004): '${chosen.color}' — altı haneli hex olmalı, yoksa üç gölge birden görünmez olur`);
+        gaps.add('shadow');
+        return;
+    }
+    const opacity = chosen.opacity <= 1 ? Math.round(chosen.opacity * 100) : Math.round(chosen.opacity);
+    const shadow = { offsetX: chosen.offsetX, offsetY: chosen.offsetY, blur: chosen.blur, spread: chosen.spread, color: parsed.hex, opacity };
+    const same = JSON.stringify(shadow) === JSON.stringify(TOKENS.shadow);
+    if (parsed.hex !== chosen.color.trim() || parsed.note !== undefined) {
+        draft.normalized.push(`${chosen.name}: shadow.color '${chosen.color}' → '${parsed.hex}'${parsed.note === undefined ? '' : ` (${parsed.note}; gölge saydamlığı 'opacity' alanıdır)`}`);
+    }
+    if (chosen.opacity <= 1)
+        draft.normalized.push(`${chosen.name}: shadow.opacity ${chosen.opacity} → ${opacity} (tema 0–100 yüzde ister)`);
+    if (!same)
+        draft.set('shadow', shadow);
+    draft.map({ source: chosen.name, value: chosen.blur, path: 'shadow', via: 'effect', note: same ? 'platform varsayılanına eşit, yazılmadı' : undefined });
+}
+function mapComponents(draft, snapshot) {
+    /** Tip → verilmiş versiyon sayısı; `button/primary` V1, `button/secondary` V2 … (g-05). */
+    const versionsByType = new Map();
+    for (const [name, spec] of Object.entries(snapshot.components ?? {})) {
+        const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+        if (!isValidPresetName(slug)) {
+            draft.drop(name, JSON.stringify(spec), `preset adı geçersiz ('${slug}') — 1–40 karakter, '$' ile başlamaz`);
+            continue;
+        }
+        // Yanıt gövdesinde anahtar adı gizli-anahtar desenine uyarsa `maskSecrets` değeri '***' yapar ve
+        // ajan onu theme_update'e kopyalar (B-8; themes.ts'teki `tokens` vakasıyla aynı tuzak).
+        if (secretKeyPattern.test(slug)) {
+            draft.drop(name, JSON.stringify(spec), `preset adı '${slug}' gateway'in gizli-anahtar maskesine takılıyor (${secretKeyPattern.source}) — yanıtta '***' olurdu; bileşeni anlık görüntüde yeniden adlandırın`);
+            continue;
+        }
+        const owner = draft.claim(`presets.${slug}`, name);
+        if (owner !== undefined) {
+            draft.drop(name, JSON.stringify(spec), `çakışma — '${owner}' da '${slug}' slug'ına iniyor; bileşeni anlık görüntüde yeniden adlandırın`);
+            continue;
+        }
+        const body = {};
+        const px = (value) => `${value}px`;
+        const colorProp = (prop, raw) => {
+            if (raw === undefined)
+                return;
+            // Değer OLDUĞU GİBİ yazılır (CSS rgba/alfa çizer — B-6); yalnız alfasız düz renk eşlenmiş bir
+            // palet değerine denk geliyorsa var(--ng-*)'a bağlanır ki preset temayı izlesin (K6).
+            const parsed = hasAlpha(raw) ? undefined : normalizeHex(raw);
+            const variable = parsed === undefined ? undefined : draft.paletteVars.get(parsed.hex);
+            if (variable !== undefined) {
+                body[prop] = `var(${variable})`;
+                draft.map({ source: `${name}.${prop}`, value: raw, path: `presets.${slug}.${prop}`, via: 'component→var', note: `${parsed.hex} eşlenmiş bir palet değeri — preset temayı izlesin diye ${variable}'a bağlandı` });
+                return;
+            }
+            body[prop] = raw;
+        };
+        colorProp('background', spec.background);
+        // Zemini accent.primary olan bileşenin düz metin rengi "accent üstündeki metin"dir (f-08):
+        // palette.accent.onPrimary önerilir; aynı değer sessiz, farklı değer çakışma. Önce önerilir ki
+        // aşağıdaki colorProp('color') aynı hex'i var(--ng-text-on-accent)'e bağlasın.
+        if (body.background === `var(${paletteVar('accent', 'primary')})` && spec.color !== undefined && !hasAlpha(spec.color)) {
+            const parsedColor = normalizeHex(spec.color);
+            if (parsedColor !== undefined && draft.get('palette.accent.onPrimary') !== parsedColor.hex) {
+                draft.color(`${name}.color`, spec.color, 'palette.accent.onPrimary', 'component', `'${name}' zemini accent.primary — metin rengi accent üstündeki metin (--ng-text-on-accent) olarak önerildi; verilmezse platform kontrasttan türetir`);
+            }
+        }
+        colorProp('color', spec.color);
+        colorProp('border', spec.border);
+        if (spec.paddingX !== undefined || spec.paddingY !== undefined)
+            body.padding = `${px(spec.paddingY ?? 0)} ${px(spec.paddingX ?? 0)}`;
+        if (spec.borderRadius !== undefined)
+            body.borderRadius = typeof spec.borderRadius === 'number' ? px(spec.borderRadius) : spec.borderRadius;
+        if (spec.height !== undefined)
+            body.minHeight = px(spec.height);
+        if (spec.fontSize !== undefined)
+            body.fontSize = px(spec.fontSize);
+        if (spec.fontWeight !== undefined)
+            body.fontWeight = String(spec.fontWeight);
+        if (spec.shadow !== undefined)
+            body.boxShadow = spec.shadow;
+        if (Object.keys(body).length === 0) {
+            draft.drop(name, JSON.stringify(spec), 'ölçü yok — boş preset yazılmaz');
+            continue;
+        }
+        draft.set(`presets.${slug}`, body);
+        // Bileşen preseti (g-05): adın ilk kelimesi katalogdaki bir TİP ise o tipin yeni düğümleri bu
+        // ölçülerle doğsun. Tip tahmini yok ('input' ≠ 'textinput'); gövde `props.style` zarfındadır
+        // (N-2 ile aynı biçim), prop adı eşlemesi (height → size) yapılmaz.
+        const type = words(name)[0] ?? '';
+        if (!(type in componentKnowledge)) {
+            draft.map({ source: name, value: JSON.stringify(spec), path: `presets.${slug}`, via: 'component', note: `'${type}' katalog tipi değil, componentPresets üretilmedi — bileşen preseti istiyorsanız adı katalog tipiyle başlatın (component_list)` });
+            continue;
+        }
+        draft.map({ source: name, value: JSON.stringify(spec), path: `presets.${slug}`, via: 'component' });
+        const count = (versionsByType.get(type) ?? 0) + 1;
+        if (count > MAX_PRESET_VERSIONS) {
+            draft.drop(name, JSON.stringify(spec), `'${type}' tipi ${MAX_PRESET_VERSIONS} versiyonla doldu (V1…V${MAX_PRESET_VERSIONS}, THEME-002) — bileşen preseti yazılmadı, adlı preset '${slug}' yazıldı`);
+            continue;
+        }
+        versionsByType.set(type, count);
+        const version = `V${count}`;
+        if (count === 1)
+            draft.set(`componentPresets.${type}.defaultVersion`, 'V1');
+        draft.set(`componentPresets.${type}.versions.${version}`, { props: { style: { ...body } } });
+        draft.map({ source: name, value: JSON.stringify(spec), path: `componentPresets.${type}.versions.${version}`, via: 'component', note: count === 1 ? `'${type}' tipinden bırakılan yeni düğümler bu stille başlar (defaultVersion V1); mevcut düğümler için adlı preset '${slug}'` : undefined });
+    }
+}
+/** Koyu palet türetme (g-06): yalnız bayrakla, yalnız aydınlıkta YAZILAN accent/status anahtarları. */
+function deriveDarkPalette(draft, snapshot) {
+    if (Object.keys(snapshot.variablesDark ?? {}).length > 0) {
+        draft.normalized.push('deriveDark yok sayıldı — anlık görüntüde variablesDark var; gerçek koyu küme türetmeden üstündür');
+        return;
+    }
+    for (const entry of [...draft.mapping]) {
+        const match = /^palette\.((?:accent|status)\.[a-zA-Z]+)$/.exec(entry.path);
+        if (match === null)
+            continue;
+        const rule = DERIVE_DARK[match[1]];
+        const light = draft.get(entry.path);
+        if (rule === undefined || typeof light !== 'string')
+            continue;
+        const path = `paletteDark.${match[1]}`;
+        if (draft.claim(path, `${entry.source} (derived)`) !== undefined)
+            continue;
+        const derived = mixHex(light, rule.toward, rule.ratio);
+        draft.set(path, derived);
+        draft.map({
+            source: entry.source,
+            value: light,
+            path,
+            via: 'derived',
+            note: `türetildi — Figma'da koyu küme yok; ${light} ${rule.toward === 255 ? 'beyazla' : 'siyahla'} %${Math.round(rule.ratio * 100)} karıştırıldı. Marka kararı değil başlangıç noktası; koyu ekranı page_screenshot(colorScheme:'dark') ile görüp değeri değiştirin`
+        });
+    }
+}
+/** Tipografi kaynaklarını role göre birleştirir; aynı alanın ikinci FARKLI değeri çakışmadır (B-5). */
+class TypographyPool {
+    draft;
+    records = new Map();
+    constructor(draft) {
+        this.draft = draft;
+    }
+    add(role, source, raw, fields) {
+        if (role === undefined) {
+            this.draft.drop(source, raw, 'rol tanınmadı — role verin (h1 · h2 · h3 · h4 · label · p · small) ya da ad rol kelimesi taşısın (body, h1, caption …)');
+            return;
+        }
+        const current = this.records.get(role);
+        if (current === undefined) {
+            this.records.set(role, { role, ...fields });
+            return;
+        }
+        const conflicts = [];
+        for (const key of ['family', 'size', 'weight']) {
+            const incoming = fields[key];
+            const existing = current[key];
+            if (incoming === undefined || existing === undefined)
+                continue;
+            if (String(incoming.value).trim().toLowerCase() === String(existing.value).trim().toLowerCase())
+                continue;
+            conflicts.push(`${key}: '${existing.source}' ${role} seviyesini aldı (${String(existing.value)} ≠ ${String(incoming.value)})`);
+        }
+        if (conflicts.length > 0) {
+            this.draft.drop(source, raw, `çakışma — ${conflicts.join('; ')}; fazlasını anlık görüntüden çıkarın ya da role verin`);
+            return;
+        }
+        for (const key of ['family', 'size', 'weight']) {
+            const incoming = fields[key];
+            if (incoming !== undefined && current[key] === undefined)
+                current[key] = incoming;
+        }
+    }
+}
+export function discoverTheme(snapshot, options = {}) {
+    const draft = new ThemeDraft();
+    const gaps = new Set();
+    const hints = new Map();
+    const known = new Set([...Object.keys(snapshot.variables), ...Object.keys(snapshot.variablesDark ?? {})]);
+    const unknownHints = Object.keys(snapshot.hints ?? {}).filter(name => !known.has(name));
+    // Anlık görüntüde olmayan bir ada verilen hint sessizce ölmesin: Figma'da ad değişince karar da
+    // değişmelidir (B-12). Hints yalnız `variables` / `variablesDark` adlarına uygulanır.
+    if (unknownHints.length > 0) {
+        throw new PlatformApiError(`hints: ${unknownHints.map(name => `'${name}'`).join(', ')} anlık görüntünün variables/variablesDark kümesinde yok — Figma'da ad değiştiyse hints'i de güncelleyin.`, 400);
+    }
+    for (const [source, hint] of Object.entries(snapshot.hints ?? {}))
+        hints.set(source, parseHint(hint));
+    const spacing = [];
+    const radius = [];
+    const typography = new TypographyPool(draft);
+    /** Hint kümeyi bilir: çıplak yol o kümenin paletine, açık kök yalnız kendi kümesine (B-1). */
+    const consumeHint = (source, raw, set) => {
+        const hint = hints.get(source);
+        if (hint === undefined)
+            return false;
+        if (hint.kind === 'ignore') {
+            draft.drop(source, raw, `hints: ${SNAPSHOT_HINT_IGNORE}`);
+        }
+        else if (hint.kind === 'ramp') {
+            if (set === 'paletteDark')
+                draft.drop(source, raw, 'rampa moda göre ayrılmaz — colors tek kümedir; hint aydınlık kümede uygulandı');
+            else
+                draft.color(source, raw, `colors.${hint.family}.${hint.key}`, 'hint');
+        }
+        else if (hint.root !== undefined && hint.root !== set) {
+            draft.drop(source, raw, `hint '${hint.root}.${hint.group}.${hint.key}' bu küme (${set === 'palette' ? 'variables' : 'variablesDark'}) için değil — iki kümeye birden çıplak '${hint.group}.${hint.key}' yazın`);
+        }
+        else {
+            draft.color(source, raw, `${set}.${hint.group}.${hint.key}`, 'hint');
+        }
+        return true;
+    };
+    // 1. geçiş: hints — açık karar, rol tablosundan önce yolu alır.
+    for (const [source, raw] of Object.entries(snapshot.variables))
+        consumeHint(source, raw, 'palette');
+    for (const [source, raw] of Object.entries(snapshot.variablesDark ?? {}))
+        consumeHint(source, raw, 'paletteDark');
+    // 2. geçiş: aydınlık küme, türüne göre.
+    for (const [source, raw] of Object.entries(snapshot.variables)) {
+        if (hints.has(source))
+            continue;
+        const kind = classify(source, raw);
+        const list = words(source);
+        if (kind === 'color') {
+            mapColorByName(draft, source, raw, 'palette');
+        }
+        else if (kind === 'spacing' || kind === 'radius') {
+            const value = parseLength(raw);
+            if (value === undefined) {
+                draft.drop(source, raw, `uzunluk değil: '${raw}' — sayı ya da 'NNpx' bekleniyor`);
+                continue;
+            }
+            ;
+            (kind === 'spacing' ? spacing : radius).push({ source, raw, value, level: levelOf(list) });
+        }
+        else if (kind === 'typography') {
+            const role = list.map(word => ROLE_WORDS[word] ?? (word === 'heading' ? 'h1' : undefined)).find(level => level !== undefined);
+            const field = { value: raw, source, raw };
+            const font = parseFontValue(raw);
+            if (font !== undefined) {
+                typography.add(role, source, raw, {
+                    family: { ...field, value: font.family },
+                    ...(font.size === undefined ? {} : { size: { ...field, value: font.size } }),
+                    ...(font.weight === undefined ? {} : { weight: { ...field, value: font.weight } })
+                });
+            }
+            else if (has(list, ['family']))
+                typography.add(role, source, raw, { family: { ...field, value: String(raw) } });
+            else if (has(list, ['weight']))
+                typography.add(role, source, raw, { weight: field });
+            else if (has(list, ['size'])) {
+                const size = parseLength(raw);
+                if (size === undefined) {
+                    draft.drop(source, raw, `punto değil: '${raw}' — sayı ya da 'NNpx' bekleniyor`);
+                    continue;
+                }
+                typography.add(role, source, raw, { size: { ...field, value: size } });
+            }
+            else {
+                draft.drop(source, raw, "tipografi değişkeni tanınmadı — ad 'family', 'size' ya da 'weight' taşımalı (font/size/h1, font/family/body)");
+            }
+        }
+        else {
+            draft.drop(source, raw, typeof raw === 'number'
+                ? 'rol tanınmadı — sayısal değer için ad spacing/space/gap, radius/rounded ya da font/size taşımalı'
+                : 'rol tanınmadı — metin değeri renk (#…, rgb) ya da yazı tipi ailesi (font/family/…) değil');
+        }
+    }
+    // Koyu küme: yalnız renkler.
+    for (const [source, raw] of Object.entries(snapshot.variablesDark ?? {})) {
+        if (hints.has(source))
+            continue;
+        if (looksLikeColor(raw))
+            mapColorByName(draft, source, raw, 'paletteDark');
+        else
+            draft.drop(source, raw, 'koyu kümede yalnız renk okunur — ölçek ve yazı tipi moda göre ayrılmaz');
+    }
+    if (options.deriveDark === true)
+        deriveDarkPalette(draft, snapshot);
+    // Metin stilleri: tipografi kaynağı olarak birleşir (değişkenlerle aynı havuz; alan başına kaynak).
+    for (const style of snapshot.textStyles ?? []) {
+        const role = style.role ?? words(style.name).map(word => ROLE_WORDS[word]).find(level => level !== undefined);
+        typography.add(role, style.name, style.fontSize, {
+            family: { value: style.fontFamily, source: style.name, raw: style.fontFamily },
+            size: { value: style.fontSize, source: style.name, raw: style.fontSize },
+            ...(style.fontWeight === undefined ? {} : { weight: { value: style.fontWeight, source: style.name, raw: style.fontWeight } })
+        });
+    }
+    mapLengths(draft, spacing, 'spacing', gaps);
+    mapLengths(draft, radius, 'radius', gaps);
+    mapTypography(draft, [...typography.records.values()], gaps);
+    mapShadow(draft, snapshot, gaps);
+    mapComponents(draft, snapshot);
+    const theme = draft.theme();
+    if (theme.paletteDark === undefined)
+        gaps.add('paletteDark');
+    return {
+        theme,
+        mapping: draft.mapping,
+        unmapped: draft.unmapped,
+        gaps: [...gaps],
+        normalized: draft.normalized
+    };
+}