mycai 1.0.0

package/dist/resonance_sdk.js

@@ -0,0 +1,2703 @@
+// core/morphology.js
+var TurkishMorphology = class {
+  constructor(roots = []) {
+    this.onVowels = /* @__PURE__ */ new Set(["e", "i", "\xF6", "\xFC"]);
+    this.backVowels = /* @__PURE__ */ new Set(["a", "\u0131", "o", "u"]);
+    this.allVowels = /* @__PURE__ */ new Set(["a", "e", "\u0131", "i", "o", "\xF6", "u", "\xFC"]);
+    this.customRoots = roots;
+    this.suffixFeatures = {
+      // Plural
+      "ler": { number: "plural" },
+      "lar": { number: "plural" },
+      // Cases
+      "den": { case: "ablative" },
+      "dan": { case: "ablative" },
+      "ten": { case: "ablative" },
+      "tan": { case: "ablative" },
+      "de": { case: "locative" },
+      "da": { case: "locative" },
+      "te": { case: "locative" },
+      "ta": { case: "locative" },
+      "e": { case: "dative" },
+      "a": { case: "dative" },
+      "in": { case: "genitive" },
+      "\u0131n": { case: "genitive" },
+      "un": { case: "genitive" },
+      "\xFCn": { case: "genitive" },
+      // Possessions
+      "im": { possession: "1sg" },
+      "\u0131m": { possession: "1sg" },
+      "um": { possession: "1sg" },
+      "\xFCm": { possession: "1sg" },
+      "in": { possession: "2sg" },
+      // overlaps with genitive, handled dynamically
+      "\u0131n": { possession: "2sg" },
+      "un": { possession: "2sg" },
+      "\xFCn": { possession: "2sg" },
+      "i": { possession: "3sg" },
+      "\u0131": { possession: "3sg" },
+      "u": { possession: "3sg" },
+      "\xFC": { possession: "3sg" },
+      "imiz": { possession: "1pl" },
+      "\u0131m\u0131z": { possession: "1pl" },
+      "umuz": { possession: "1pl" },
+      "\xFCm\xFCz": { possession: "1pl" },
+      "iniz": { possession: "2pl" },
+      "\u0131n\u0131z": { possession: "2pl" },
+      "\xFCn\xFCz": { possession: "2pl" },
+      "unuz": { possession: "2pl" },
+      "leri": { possession: "3pl" },
+      "lar\u0131": { possession: "3pl" },
+      // Tense/Aspect/Mood
+      "iyor": { tense: "present" },
+      "\u0131yor": { tense: "present" },
+      "uyor": { tense: "present" },
+      "\xFCyor": { tense: "present" },
+      "ecek": { tense: "future" },
+      "acak": { tense: "future" },
+      "mi\u015F": { tense: "narrative_past" },
+      "m\u0131\u015F": { tense: "narrative_past" },
+      "m\xFC\u015F": { tense: "narrative_past" },
+      "mu\u015F": { tense: "narrative_past" },
+      "di": { tense: "past" },
+      "d\u0131": { tense: "past" },
+      "du": { tense: "past" },
+      "d\xFC": { tense: "past" },
+      "ti": { tense: "past" },
+      "t\u0131": { tense: "past" },
+      "tu": { tense: "past" },
+      "t\xFC": { tense: "past" },
+      // Infinitives and derivations
+      "mek": { aspect: "infinitive" },
+      "mak": { aspect: "infinitive" },
+      "lik": { derivation: "noun" },
+      "l\u0131k": { derivation: "noun" },
+      "luk": { derivation: "noun" },
+      "l\xFCk": { derivation: "noun" },
+      "li": { derivation: "with" },
+      "l\u0131": { derivation: "with" },
+      "lu": { derivation: "with" },
+      "l\xFC": { derivation: "with" },
+      "siz": { derivation: "without" },
+      "s\u0131z": { derivation: "without" },
+      "suz": { derivation: "without" },
+      "s\xFCz": { derivation: "without" },
+      "ce": { case: "equative" },
+      "ca": { case: "equative" },
+      "\xE7a": { case: "equative" },
+      "\xE7e": { case: "equative" },
+      // Copula (Assertive)
+      "dir": { copula: "assertive" },
+      "d\u0131r": { copula: "assertive" },
+      "dur": { copula: "assertive" },
+      "d\xFCr": { copula: "assertive" },
+      "tir": { copula: "assertive" },
+      "t\u0131r": { copula: "assertive" },
+      "tur": { copula: "assertive" },
+      "t\xFCr": { copula: "assertive" },
+      // Relative Modifier
+      "ki": { pronoun: "relative" },
+      "kiler": { pronoun: "relative_plural" },
+      // Adverbial / Manner
+      "cesine": { aspect: "manner" },
+      "cas\u0131na": { aspect: "manner" },
+      "ken": { adverb: "temporal" },
+      // Moods
+      "meli": { mood: "necessity" },
+      "mal\u0131": { mood: "necessity" },
+      "se": { mood: "conditional" },
+      "sa": { mood: "conditional" }
+    };
+    this.suffixesKnown = Object.keys(this.suffixFeatures).sort((a, b) => b.length - a.length);
+  }
+  // Allow dynamic roots fallback
+  get roots() {
+    if (this.customRoots && this.customRoots.length > 0) {
+      return this.customRoots;
+    }
+    if (typeof globalThis !== "undefined" && globalThis.TR_CORPUS_ROOTS) {
+      return globalThis.TR_CORPUS_ROOTS;
+    }
+    return [
+      // Genel yaygın kökler
+      "ev",
+      "g\xF6l",
+      "araba",
+      "kitap",
+      "el",
+      "ba\u015F",
+      "git",
+      "gel",
+      "yap",
+      "al",
+      "ver",
+      "g\xF6r",
+      "bilgisayar",
+      "bil",
+      "\xF6\u011Fren",
+      "anla",
+      "d\xFC\u015F\xFCn",
+      "b\xFCy\xFCk",
+      "k\xFC\xE7\xFCk",
+      "g\xFCzel",
+      "iyi",
+      "k\xF6t\xFC",
+      "yapay",
+      "zeka",
+      "beyin",
+      "sinir",
+      "dil",
+      "kelime",
+      "c\xFCmle",
+      "t\xFCrk\xE7e",
+      "bilim",
+      "teknik",
+      "okul",
+      "\xF6\u011Frenci",
+      "\xF6\u011Fretmen",
+      "yaz\u0131l\u0131m",
+      "donan\u0131m",
+      "renk",
+      // Vücut / anatomi
+      "ayak",
+      "g\xF6z",
+      "kulak",
+      "diz",
+      "omuz",
+      "kar\u0131n",
+      "g\xF6\u011F\xFCs",
+      "s\u0131rt",
+      "boyun",
+      "kol",
+      "bacak",
+      "parmak",
+      "bilek",
+      "topuk",
+      "al\u0131n",
+      "bel",
+      "di\u015F",
+      "burun",
+      "a\u011F\u0131z",
+      "ci\u011Fer",
+      "kalp",
+      "akci\u011Fer",
+      "mide",
+      "b\xF6brek",
+      "karaci\u011Fer",
+      "damar",
+      // Tıbbi terimler
+      "hasta",
+      "doktor",
+      "hem\u015Fire",
+      "ila\xE7",
+      "doz",
+      "tan\u0131",
+      "tedavi",
+      "ameliyat",
+      "hastal\u0131k",
+      "a\u011Fr\u0131",
+      "\u015Fi\u015Flik",
+      "ate\u015F",
+      "nab\u0131z",
+      "tansiyon",
+      "kan",
+      "idrar",
+      "re\xE7ete",
+      "a\u015F\u0131",
+      "vir\xFCs",
+      "enfeksiyon",
+      "yara",
+      "k\u0131r\u0131k",
+      "\xF6dem",
+      "alerji",
+      "\u015Feker",
+      "diyabet",
+      "gebelik",
+      "do\u011Fum",
+      "\xF6l\xE7\xFCm",
+      "muayene",
+      "rapor",
+      "tahlil",
+      // Genel isimler
+      "yol",
+      "su",
+      "ekmek",
+      "para",
+      "i\u015F",
+      "g\xFCn",
+      "y\u0131l",
+      "saat",
+      "hafta",
+      "ay",
+      "yer",
+      "\u015Fehir",
+      "\xFClke",
+      "k\xF6y",
+      "insan",
+      "kad\u0131n",
+      "erkek",
+      "\xE7ocuk",
+      "anne",
+      "baba",
+      "ad",
+      "isim",
+      "aile",
+      "soru",
+      "cevap",
+      "kay\u0131t",
+      "bilgi",
+      "durum",
+      "sonu\xE7",
+      // Sıfatlar ve zarflar
+      "yeni",
+      "eski",
+      "uzun",
+      "k\u0131sa",
+      "s\u0131k",
+      "az",
+      "\xE7ok",
+      "son",
+      "ilk",
+      "her",
+      // Fiiller (ek kökler)
+      "oku",
+      "yaz",
+      "bak",
+      "\xE7al\u0131\u015F",
+      "ye",
+      "i\xE7",
+      "uyu",
+      "kalk",
+      "otur",
+      "ko\u015F",
+      "sor",
+      "s\xF6yle",
+      "dinle",
+      "bekle",
+      "ba\u015Fla",
+      "bitir",
+      "a\xE7",
+      "kapat",
+      "getir",
+      "g\xF6t\xFCr",
+      "koy",
+      "\xE7\u0131kar",
+      "kaydet",
+      "g\xFCncelle",
+      "kontrol"
+    ];
+  }
+  determineVowelHarmony(root) {
+    const lv = this.getLastVowel(root);
+    return lv && this.onVowels.has(lv) ? "front" : "back";
+  }
+  getLastVowel(word) {
+    for (let i = word.length - 1; i >= 0; i--) {
+      if (this.allVowels.has(word[i])) return word[i];
+    }
+    return null;
+  }
+  normalize(text) {
+    return text.toLowerCase().trim().replace(/i̇/g, "i").replace(/[^a-zçgğıoöşuüâîû\s]/g, "");
+  }
+  analyze(word) {
+    const w = this.normalize(word).split(/\s+/)[0];
+    const result = {
+      word: w,
+      root: w,
+      suffixes: [],
+      harmony: this.determineVowelHarmony(w),
+      morphemes: [],
+      features: {},
+      vowelCount: 0,
+      syllables: []
+    };
+    if (!w) return result;
+    result.vowelCount = [...w].filter((c) => this.allVowels.has(c)).length;
+    result.syllables = this.syllabify(w);
+    let foundRoot = w;
+    let foundSuffs = [];
+    for (const root of this.roots) {
+      let isMatch = false;
+      let matchedLength = root.length;
+      if (w.startsWith(root)) {
+        isMatch = true;
+      } else {
+        const last = root[root.length - 1];
+        if (["p", "\xE7", "t", "k"].includes(last)) {
+          const stem = root.slice(0, -1);
+          let mutatedStem = "";
+          if (last === "p") mutatedStem = stem + "b";
+          else if (last === "\xE7") mutatedStem = stem + "c";
+          else if (last === "t") mutatedStem = stem + "d";
+          else if (last === "k") mutatedStem = stem + "\u011F";
+          if (root === "renk") mutatedStem = stem + "g";
+          if (w.startsWith(mutatedStem) && w.length > root.length) {
+            const nextChar = w[mutatedStem.length];
+            if (this.allVowels.has(nextChar)) {
+              isMatch = true;
+              matchedLength = mutatedStem.length;
+            }
+          }
+        }
+      }
+      if (isMatch && root.length >= 2 && root.length < w.length) {
+        const suffix = w.slice(matchedLength);
+        if (root.length > (foundRoot === w ? 0 : foundRoot.length)) {
+          foundRoot = root;
+          foundSuffs = this.splitSuffix(suffix);
+        }
+      }
+    }
+    result.root = foundRoot;
+    result.suffixes = foundSuffs;
+    result.morphemes = [foundRoot, ...foundSuffs].filter(Boolean);
+    result.harmony = this.determineVowelHarmony(foundRoot);
+    foundSuffs.forEach((suff) => {
+      const feat = this.suffixFeatures[suff];
+      if (feat) {
+        Object.assign(result.features, feat);
+      }
+    });
+    return result;
+  }
+  splitSuffix(suffix) {
+    if (!suffix) return [];
+    const result = [];
+    let rem = suffix;
+    while (rem.length > 0) {
+      let matched = false;
+      for (const s of this.suffixesKnown) {
+        if (rem.endsWith(s)) {
+          result.unshift(s);
+          rem = rem.slice(0, rem.length - s.length);
+          matched = true;
+          break;
+        }
+      }
+      if (!matched) {
+        result.unshift(rem);
+        break;
+      }
+    }
+    return result;
+  }
+  syllabify(word) {
+    const w = this.normalize(word);
+    if (!w) return [];
+    const vowelIndices = [];
+    for (let i = 0; i < w.length; i++) {
+      if (this.allVowels.has(w[i])) {
+        vowelIndices.push(i);
+      }
+    }
+    if (vowelIndices.length <= 1) {
+      return [w];
+    }
+    const syllables = [];
+    let start = 0;
+    for (let k = 0; k < vowelIndices.length - 1; k++) {
+      const v1 = vowelIndices[k];
+      const v2 = vowelIndices[k + 1];
+      const consonantCount = v2 - v1 - 1;
+      let splitPoint;
+      if (consonantCount === 0) {
+        splitPoint = v1 + 1;
+      } else if (consonantCount === 1) {
+        splitPoint = v1 + 1;
+      } else if (consonantCount === 2) {
+        splitPoint = v1 + 2;
+      } else {
+        splitPoint = v2 - 1;
+      }
+      syllables.push(w.slice(start, splitPoint));
+      start = splitPoint;
+    }
+    syllables.push(w.slice(start));
+    return syllables.filter(Boolean);
+  }
+  syllabifyPhrase(phrase) {
+    const words = phrase.toLowerCase().trim().split(/\s+/).filter(Boolean);
+    if (words.length === 0) return [];
+    if (words.length === 1) return this.syllabify(words[0]);
+    const resultSyllables = [];
+    const processedWords = [...words];
+    for (let i = 0; i < processedWords.length - 1; i++) {
+      const w1 = processedWords[i];
+      const w2 = processedWords[i + 1];
+      if (w1.length === 0 || w2.length === 0) continue;
+      const lastChar = w1[w1.length - 1];
+      const firstChar = w2[0];
+      if (!this.allVowels.has(lastChar) && this.allVowels.has(firstChar)) {
+        processedWords[i] = w1.slice(0, -1);
+        processedWords[i + 1] = lastChar + w2;
+      }
+    }
+    for (const w of processedWords) {
+      if (w.length > 0) {
+        resultSyllables.push(...this.syllabify(w));
+      }
+    }
+    return resultSyllables;
+  }
+};
+
+// core/hdc.js
+var Representation = class {
+  constructor(type, values, D) {
+    this.type = type;
+    this.values = values;
+    this.D = D;
+  }
+  // Calculate memory footprint in bytes
+  memorySize() {
+    return this.values.byteLength;
+  }
+};
+var HDCEngine = class {
+  constructor(D = 8192) {
+    this.D = D;
+  }
+  // ── GENERATION / RANDOM RANDOM VECTORS ─────────────────────
+  generateRandom(type) {
+    if (type === "binary") {
+      const vals2 = new Uint8Array(this.D);
+      for (let i = 0; i < this.D; i++) {
+        vals2[i] = Math.random() < 0.5 ? 0 : 1;
+      }
+      return new Representation("binary", vals2, this.D);
+    }
+    if (type === "bipolar") {
+      const vals2 = new Float32Array(this.D);
+      for (let i = 0; i < this.D; i++) {
+        vals2[i] = Math.random() < 0.5 ? -1 : 1;
+      }
+      return new Representation("bipolar", vals2, this.D);
+    }
+    if (type === "real") {
+      const vals2 = new Float32Array(this.D);
+      for (let i = 0; i < this.D; i++) {
+        let u = 0, v = 0;
+        while (u === 0) u = Math.random();
+        while (v === 0) v = Math.random();
+        vals2[i] = Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v);
+      }
+      return new Representation("real", vals2, this.D);
+    }
+    const vals = new Float32Array(this.D);
+    for (let i = 0; i < this.D; i++) {
+      vals[i] = Math.random() * 2 * Math.PI;
+    }
+    return new Representation("complex", vals, this.D);
+  }
+  generateSeeded(type, key) {
+    let seed = 0;
+    for (let i = 0; i < key.length; i++) {
+      seed = seed * 31 + key.charCodeAt(i) >>> 0;
+    }
+    const nextRand = () => {
+      seed = seed * 1664525 + 1013904223 >>> 0;
+      return (seed >>> 8) / 16777216;
+    };
+    if (type === "binary") {
+      const vals2 = new Uint8Array(this.D);
+      for (let i = 0; i < this.D; i++) {
+        vals2[i] = nextRand() < 0.5 ? 0 : 1;
+      }
+      return new Representation("binary", vals2, this.D);
+    }
+    if (type === "bipolar") {
+      const vals2 = new Float32Array(this.D);
+      for (let i = 0; i < this.D; i++) {
+        vals2[i] = nextRand() < 0.5 ? -1 : 1;
+      }
+      return new Representation("bipolar", vals2, this.D);
+    }
+    if (type === "real") {
+      const vals2 = new Float32Array(this.D);
+      for (let i = 0; i < this.D; i++) {
+        let u = 0, v = 0;
+        while (u === 0) u = nextRand();
+        while (v === 0) v = nextRand();
+        vals2[i] = Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v);
+      }
+      return new Representation("real", vals2, this.D);
+    }
+    const vals = new Float32Array(this.D);
+    for (let i = 0; i < this.D; i++) {
+      vals[i] = nextRand() * 2 * Math.PI;
+    }
+    return new Representation("complex", vals, this.D);
+  }
+  // ── BINDING (Morfem Binding / Variable-Value Association) ──
+  bind(a, b) {
+    if (a.type !== b.type || a.D !== b.D) {
+      throw new Error("Representation mismatch for bind operation.");
+    }
+    const D = a.D;
+    if (a.type === "binary") {
+      const o2 = new Uint8Array(D);
+      for (let i = 0; i < D; i++) {
+        o2[i] = a.values[i] ^ b.values[i];
+      }
+      return new Representation("binary", o2, D);
+    }
+    if (a.type === "bipolar") {
+      const o2 = new Float32Array(D);
+      for (let i = 0; i < D; i++) {
+        o2[i] = a.values[i] * b.values[i];
+      }
+      return new Representation("bipolar", o2, D);
+    }
+    if (a.type === "real") {
+      const o2 = new Float32Array(D);
+      for (let i = 0; i < D; i++) {
+        o2[i] = a.values[i] * b.values[i];
+      }
+      return new Representation("real", o2, D);
+    }
+    const o = new Float32Array(D);
+    for (let i = 0; i < D; i++) {
+      o[i] = (a.values[i] + b.values[i]) % (2 * Math.PI);
+    }
+    return new Representation("complex", o, D);
+  }
+  unbind(a, b) {
+    if (a.type !== b.type || a.D !== b.D) {
+      throw new Error("Representation mismatch for unbind operation.");
+    }
+    const D = a.D;
+    if (a.type === "binary") {
+      return this.bind(a, b);
+    }
+    if (a.type === "bipolar") {
+      return this.bind(a, b);
+    }
+    if (a.type === "real") {
+      const o2 = new Float32Array(D);
+      for (let i = 0; i < D; i++) {
+        o2[i] = Math.abs(b.values[i]) > 1e-6 ? a.values[i] / b.values[i] : a.values[i];
+      }
+      return new Representation("real", o2, D);
+    }
+    const o = new Float32Array(D);
+    for (let i = 0; i < D; i++) {
+      let v = a.values[i] - b.values[i];
+      if (v < 0) v += 2 * Math.PI;
+      o[i] = v % (2 * Math.PI);
+    }
+    return new Representation("complex", o, D);
+  }
+  // ── BUNDLING (Superposition / Memory Accumulation) ──────────
+  bundle(reps) {
+    if (!reps || reps.length === 0) {
+      throw new Error("No representations to bundle.");
+    }
+    const type = reps[0].type;
+    const D = reps[0].D;
+    if (type === "binary") {
+      const o2 = new Uint8Array(D);
+      const counts = new Int32Array(D);
+      for (const r of reps) {
+        for (let i = 0; i < D; i++) {
+          counts[i] += r.values[i] === 1 ? 1 : -1;
+        }
+      }
+      for (let i = 0; i < D; i++) {
+        o2[i] = counts[i] >= 0 ? 1 : 0;
+      }
+      return new Representation("binary", o2, D);
+    }
+    if (type === "bipolar") {
+      const o2 = new Float32Array(D);
+      for (const r of reps) {
+        for (let i = 0; i < D; i++) {
+          o2[i] += r.values[i];
+        }
+      }
+      for (let i = 0; i < D; i++) {
+        o2[i] = o2[i] >= 0 ? 1 : -1;
+      }
+      return new Representation("bipolar", o2, D);
+    }
+    if (type === "real") {
+      const o2 = new Float32Array(D);
+      for (const r of reps) {
+        for (let i = 0; i < D; i++) {
+          o2[i] += r.values[i];
+        }
+      }
+      const n = reps.length;
+      for (let i = 0; i < D; i++) {
+        o2[i] /= n;
+      }
+      return new Representation("real", o2, D);
+    }
+    const re = new Float32Array(D);
+    const im = new Float32Array(D);
+    for (const r of reps) {
+      for (let i = 0; i < D; i++) {
+        re[i] += Math.cos(r.values[i]);
+        im[i] += Math.sin(r.values[i]);
+      }
+    }
+    const o = new Float32Array(D);
+    for (let i = 0; i < D; i++) {
+      let v = Math.atan2(im[i], re[i]);
+      if (v < 0) v += 2 * Math.PI;
+      o[i] = v;
+    }
+    return new Representation("complex", o, D);
+  }
+  // ── PERMUTATION (Shift operation / Order / Position binding) ─
+  permute(a, sh) {
+    const D = a.D;
+    const shift = (sh % D + D) % D;
+    const vals = new a.values.constructor(D);
+    for (let i = 0; i < D; i++) {
+      vals[(i + shift) % D] = a.values[i];
+    }
+    return new Representation(a.type, vals, D);
+  }
+  // ── SIMILARITY (Measured closeness) ──────────────────────────
+  similarity(a, b) {
+    if (a.type !== b.type || a.D !== b.D) {
+      return 0;
+    }
+    const D = a.D;
+    if (a.type === "binary") {
+      let hamming = 0;
+      for (let i = 0; i < D; i++) {
+        if (a.values[i] !== b.values[i]) hamming++;
+      }
+      return 1 - hamming / D;
+    }
+    if (a.type === "bipolar") {
+      let dot = 0;
+      for (let i = 0; i < D; i++) {
+        dot += a.values[i] * b.values[i];
+      }
+      return dot / D;
+    }
+    if (a.type === "real") {
+      let dot = 0, normA = 0, normB = 0;
+      for (let i = 0; i < D; i++) {
+        dot += a.values[i] * b.values[i];
+        normA += a.values[i] * a.values[i];
+        normB += b.values[i] * b.values[i];
+      }
+      const denom = Math.sqrt(normA) * Math.sqrt(normB);
+      return denom > 0 ? dot / denom : 0;
+    }
+    let sum = 0;
+    for (let i = 0; i < D; i++) {
+      sum += Math.cos(a.values[i] - b.values[i]);
+    }
+    return sum / D;
+  }
+};
+
+// core/memory_engine.js
+import fs from "fs";
+
+// core/spectral.js
+var SpectralEngine = class {
+  constructor() {
+  }
+  // ── FFT CORE ALGORITHMS ────────────────────────────────────
+  _bitReverse(re, im) {
+    const n = re.length;
+    let j = 0;
+    for (let i = 0; i < n; i++) {
+      if (i < j) {
+        let temp = re[i];
+        re[i] = re[j];
+        re[j] = temp;
+        temp = im[i];
+        im[i] = im[j];
+        im[j] = temp;
+      }
+      let m = n >> 1;
+      while (m >= 2 && j >= m) {
+        j -= m;
+        m >>= 1;
+      }
+      j += m;
+    }
+  }
+  _fftCore(re, im, inverse = false) {
+    const n = re.length;
+    this._bitReverse(re, im);
+    for (let len = 2; len <= n; len <<= 1) {
+      const angle = 2 * Math.PI / len * (inverse ? 1 : -1);
+      const wlen_re = Math.cos(angle);
+      const wlen_im = Math.sin(angle);
+      for (let i = 0; i < n; i += len) {
+        let w_re = 1;
+        let w_im = 0;
+        const half = len >> 1;
+        for (let j = 0; j < half; j++) {
+          const u_re = re[i + j];
+          const u_im = im[i + j];
+          const t_re = re[i + j + half];
+          const t_im = im[i + j + half];
+          const v_re = t_re * w_re - t_im * w_im;
+          const v_im = t_re * w_im + t_im * w_re;
+          re[i + j] = u_re + v_re;
+          im[i + j] = u_im + v_im;
+          re[i + j + half] = u_re - v_re;
+          im[i + j + half] = u_im - v_im;
+          const next_w_re = w_re * wlen_re - w_im * wlen_im;
+          const next_w_im = w_re * wlen_im + w_im * wlen_re;
+          w_re = next_w_re;
+          w_im = next_w_im;
+        }
+      }
+    }
+    if (inverse) {
+      for (let i = 0; i < n; i++) {
+        re[i] /= n;
+        im[i] /= n;
+      }
+    }
+  }
+  // ── EXTERNAL API ───────────────────────────────────────────
+  spectralTransform(representation) {
+    const D = representation.D;
+    const re = new Float32Array(D);
+    const im = new Float32Array(D);
+    if (representation.type === "complex") {
+      for (let i = 0; i < D; i++) {
+        re[i] = Math.cos(representation.values[i]);
+        im[i] = Math.sin(representation.values[i]);
+      }
+    } else if (representation.type === "bipolar" || representation.type === "real") {
+      for (let i = 0; i < D; i++) {
+        re[i] = representation.values[i];
+        im[i] = 0;
+      }
+    } else if (representation.type === "binary") {
+      for (let i = 0; i < D; i++) {
+        re[i] = representation.values[i] === 1 ? 1 : -1;
+        im[i] = 0;
+      }
+    }
+    this._fftCore(re, im, false);
+    const magnitude = new Float32Array(D);
+    const phase = new Float32Array(D);
+    for (let i = 0; i < D; i++) {
+      magnitude[i] = Math.sqrt(re[i] * re[i] + im[i] * im[i]);
+      phase[i] = Math.atan2(im[i], re[i]);
+    }
+    return {
+      type: representation.type,
+      D,
+      re,
+      im,
+      magnitude,
+      phase
+    };
+  }
+  inverseSpectralTransform(spectrum) {
+    const D = spectrum.D;
+    const re = new Float32Array(spectrum.re);
+    const im = new Float32Array(spectrum.im);
+    this._fftCore(re, im, true);
+    if (spectrum.type === "complex") {
+      const vals2 = new Float32Array(D);
+      for (let i = 0; i < D; i++) {
+        let v = Math.atan2(im[i], re[i]);
+        if (v < 0) v += 2 * Math.PI;
+        vals2[i] = v;
+      }
+      return new Representation("complex", vals2, D);
+    }
+    if (spectrum.type === "binary") {
+      const vals2 = new Uint8Array(D);
+      for (let i = 0; i < D; i++) {
+        vals2[i] = re[i] >= 0 ? 1 : 0;
+      }
+      return new Representation("binary", vals2, D);
+    }
+    if (spectrum.type === "bipolar") {
+      const vals2 = new Float32Array(D);
+      for (let i = 0; i < D; i++) {
+        vals2[i] = re[i] >= 0 ? 1 : -1;
+      }
+      return new Representation("bipolar", vals2, D);
+    }
+    const vals = new Float32Array(D);
+    for (let i = 0; i < D; i++) {
+      vals[i] = re[i];
+    }
+    return new Representation("real", vals, D);
+  }
+  extractDominantFrequencies(spectrum, k = 10) {
+    const n = spectrum.D;
+    const items = [];
+    for (let i = 0; i < n; i++) {
+      items.push({ freq: i, mag: spectrum.magnitude[i] });
+    }
+    items.sort((a, b) => b.mag - a.mag);
+    return items.slice(0, k);
+  }
+  spectralEnergy(spectrum) {
+    let energy = 0;
+    const n = spectrum.D;
+    for (let i = 0; i < n; i++) {
+      energy += spectrum.magnitude[i] * spectrum.magnitude[i];
+    }
+    return energy;
+  }
+  spectralEntropy(spectrum) {
+    const n = spectrum.D;
+    const power = new Float32Array(n);
+    let totalPower = 0;
+    for (let i = 0; i < n; i++) {
+      power[i] = spectrum.magnitude[i] * spectrum.magnitude[i];
+      totalPower += power[i];
+    }
+    if (totalPower === 0) return 0;
+    let entropy = 0;
+    for (let i = 0; i < n; i++) {
+      const p = power[i] / totalPower;
+      if (p > 0) {
+        entropy -= p * Math.log2(p);
+      }
+    }
+    return entropy / Math.log2(n);
+  }
+  spectralSparsity(spectrum) {
+    const n = spectrum.D;
+    let l1 = 0;
+    let l2Sq = 0;
+    for (let i = 0; i < n; i++) {
+      l1 += spectrum.magnitude[i];
+      l2Sq += spectrum.magnitude[i] * spectrum.magnitude[i];
+    }
+    const l2 = Math.sqrt(l2Sq);
+    if (l2 === 0) return 0;
+    const sqrtN = Math.sqrt(n);
+    return (sqrtN - l1 / l2) / (sqrtN - 1);
+  }
+  lowFrequencyEnergy(spectrum) {
+    let energy = 0;
+    const half = Math.floor(spectrum.D / 2);
+    const quarter = Math.floor(half / 2);
+    for (let i = 0; i < quarter; i++) {
+      energy += spectrum.magnitude[i] * spectrum.magnitude[i];
+    }
+    return energy;
+  }
+  highFrequencyEnergy(spectrum) {
+    let energy = 0;
+    const half = Math.floor(spectrum.D / 2);
+    const quarter = Math.floor(half / 2);
+    for (let i = quarter; i < half; i++) {
+      energy += spectrum.magnitude[i] * spectrum.magnitude[i];
+    }
+    return energy;
+  }
+  spectralSimilarity(a, b) {
+    if (a.D !== b.D) return 0;
+    let dot = 0, normA = 0, normB = 0;
+    const n = a.D;
+    for (let i = 0; i < n; i++) {
+      dot += a.magnitude[i] * b.magnitude[i];
+      normA += a.magnitude[i] * a.magnitude[i];
+      normB += b.magnitude[i] * b.magnitude[i];
+    }
+    const denom = Math.sqrt(normA) * Math.sqrt(normB);
+    return denom > 0 ? dot / denom : 0;
+  }
+};
+
+// core/memory_engine.js
+var MemoryEngine = class {
+  /**
+   * @param {Object} config
+   * @param {number} [config.alpha=0.3] - Reinforcement saturating factor
+   * @param {number} [config.lambda=0.01] - Base decay rate per hour
+   * @param {number} [config.ws=0.4] - Semantic similarity weight
+   * @param {number} [config.wr=0.2] - Spectral resonance weight
+   * @param {number} [config.wc=0.1] - Confidence weight
+   * @param {number} [config.wf=0.1] - Reinforcement frequency weight
+   * @param {number} [config.wd=0.1] - Decay penalty weight
+   * @param {number} [config.wx=0.1] - Contradiction penalty weight
+   */
+  constructor(config = {}) {
+    this.records = /* @__PURE__ */ new Map();
+    this.recordsList = [];
+    this.spectral = new SpectralEngine();
+    this.alpha = config.alpha !== void 0 ? config.alpha : 0.3;
+    this.lambda = config.lambda !== void 0 ? config.lambda : 0.01;
+    this.ws = config.ws !== void 0 ? config.ws : 0.4;
+    this.wr = config.wr !== void 0 ? config.wr : 0.2;
+    this.wc = config.wc !== void 0 ? config.wc : 0.1;
+    this.wf = config.wf !== void 0 ? config.wf : 0.1;
+    this.wd = config.wd !== void 0 ? config.wd : 0.1;
+    this.wx = config.wx !== void 0 ? config.wx : 0.1;
+    this.numTables = 4;
+    this.numProjections = 8;
+    this.tablesProjections = null;
+    this.tablesBuckets = null;
+    this.highPriorityRecords = /* @__PURE__ */ new Map();
+    this._saveTimeout = null;
+    this._savePromise = Promise.resolve();
+  }
+  _initLSH(D) {
+    this.D = D;
+    this.tablesProjections = [];
+    this.tablesBuckets = [];
+    for (let t = 0; t < this.numTables; t++) {
+      const projections = [];
+      for (let i = 0; i < this.numProjections; i++) {
+        const vec = new Float32Array(D);
+        for (let j = 0; j < D; j++) {
+          vec[j] = Math.random() * 2 - 1;
+        }
+        projections.push(vec);
+      }
+      this.tablesProjections.push(projections);
+      this.tablesBuckets.push(Array.from({ length: 256 }, () => []));
+    }
+  }
+  _hash(vector, tableIndex) {
+    let hash = 0;
+    const projections = this.tablesProjections[tableIndex];
+    for (let i = 0; i < this.numProjections; i++) {
+      let dot = 0;
+      const p = projections[i];
+      for (let j = 0; j < this.D; j++) {
+        dot += vector[j] * p[j];
+      }
+      if (dot > 0) {
+        hash |= 1 << i;
+      }
+    }
+    return hash;
+  }
+  /**
+   * Add a new MemoryRecord and index it in the LSH tables
+   * @param {Object} item
+   * @returns {Object} Added memory record
+   */
+  addRecord(item) {
+    const t = Date.now();
+    const id = item.id || Math.random().toString(36).substring(2, 11);
+    let repr = item.representation;
+    if (!repr || repr.length === 0) {
+      repr = new Float32Array(this.D || 8192);
+    } else if (!(repr instanceof Float32Array)) {
+      repr = new Float32Array(repr);
+    }
+    const record = {
+      id,
+      representation: repr,
+      content: item.content,
+      confidence: item.confidence !== void 0 ? item.confidence : 1,
+      reinforcement: item.reinforcement !== void 0 ? item.reinforcement : 1,
+      createdAt: item.createdAt || t,
+      lastAccessedAt: item.lastAccessedAt || t,
+      lastReinforcedAt: item.lastReinforcedAt || t,
+      source: item.source || "user",
+      sourceType: item.sourceType || "user",
+      status: item.status || "active",
+      contradictionIds: item.contradictionIds || [],
+      priority: item.priority || "normal"
+      // Support priority field
+    };
+    const recordIndex = this.recordsList.length;
+    this.recordsList.push(record);
+    this.records.set(id, record);
+    if (record.priority === "high") {
+      this.highPriorityRecords.set(id, recordIndex);
+    }
+    if (!this.tablesProjections) {
+      this._initLSH(record.representation.length);
+    }
+    for (let t2 = 0; t2 < this.numTables; t2++) {
+      const hash = this._hash(record.representation, t2);
+      this.tablesBuckets[t2][hash].push(recordIndex);
+    }
+    this._checkAndFlagContradictions(record);
+    return record;
+  }
+  /**
+   * Reinforce a memory record using saturating Hebbian confidence updates
+   * @param {string} id - Record ID
+   * @param {number} [alpha=this.alpha] - Custom alpha
+   */
+  reinforce(id, alpha = this.alpha) {
+    const record = this.records.get(id);
+    if (!record) return;
+    const t = Date.now();
+    const currentC = this.getDecayedConfidence(record, t);
+    record.confidence = currentC + alpha * (1 - currentC);
+    record.reinforcement += 1;
+    record.lastReinforcedAt = t;
+  }
+  /**
+   * Get dynamically decayed confidence at a specific timestamp
+   * @param {Object} record
+   * @param {number} [currentTime=Date.now()]
+   * @returns {number} Decayed confidence in [0.0, 1.0]
+   */
+  getDecayedConfidence(record, currentTime = Date.now()) {
+    const dtMs = currentTime - record.lastReinforcedAt;
+    const dtHours = dtMs / (1e3 * 3600);
+    const logReinforce = Math.log2(record.reinforcement + 1);
+    const effLambda = this.lambda / (logReinforce || 1);
+    return record.confidence * Math.exp(-effLambda * dtHours);
+  }
+  /**
+   * Set dynamic contradiction status on two conflicting memory records
+   * @param {string} idA
+   * @param {string} idB
+   */
+  flagContradiction(idA, idB) {
+    const recA = this.records.get(idA);
+    const recB = this.records.get(idB);
+    if (recA && recB) {
+      if (!recA.contradictionIds.includes(idB)) recA.contradictionIds.push(idB);
+      if (!recB.contradictionIds.includes(idA)) recB.contradictionIds.push(idA);
+      recA.status = "conflicted";
+      recB.status = "conflicted";
+    }
+  }
+  /**
+   * Retrieve matched memory candidates using Multi-Table LSH and Multi-Probe Hamming search
+   * @param {Float32Array} queryRepr - Query FHRR vector
+   * @param {number} [limit=5]
+   * @param {number} [currentTime=Date.now()]
+   * @returns {Array} List of matched candidates and scores
+   */
+  retrieve(queryRepr, limit = 5, currentTime = Date.now()) {
+    const D = queryRepr.length;
+    if (!this.tablesProjections) {
+      this._initLSH(D);
+    }
+    const candidateIndices = /* @__PURE__ */ new Set();
+    for (const [id, recordIndex] of this.highPriorityRecords.entries()) {
+      candidateIndices.add(recordIndex);
+    }
+    let lshFoundCount = 0;
+    for (let t = 0; t < this.numTables; t++) {
+      const queryHash = this._hash(queryRepr, t);
+      const bucket = this.tablesBuckets[t][queryHash];
+      for (let i = 0; i < bucket.length; i++) {
+        candidateIndices.add(bucket[i]);
+        lshFoundCount++;
+      }
+      for (let bit = 0; bit < this.numProjections; bit++) {
+        const neighborHash = queryHash ^ 1 << bit;
+        const neighborBucket = this.tablesBuckets[t][neighborHash];
+        for (let i = 0; i < neighborBucket.length; i++) {
+          candidateIndices.add(neighborBucket[i]);
+          lshFoundCount++;
+        }
+      }
+    }
+    let fallbackTriggered = false;
+    if (lshFoundCount === 0) {
+      fallbackTriggered = true;
+    } else {
+      let maxC = -1;
+      let maxSim = -1;
+      for (const idx of candidateIndices) {
+        const record = this.recordsList[idx];
+        const C = this.getDecayedConfidence(record, currentTime);
+        if (C > maxC) maxC = C;
+        const sim = this._cosineSimilarity(queryRepr, record.representation);
+        if (sim > maxSim) maxSim = sim;
+      }
+      if (maxC < 0.45 || maxSim < 0.35) {
+        fallbackTriggered = true;
+      }
+    }
+    let indicesToSearch = candidateIndices;
+    if (fallbackTriggered) {
+      indicesToSearch = new Set(Array.from({ length: this.recordsList.length }, (_, i) => i));
+    }
+    const results = [];
+    const specQuery = this.spectral.spectralTransform({ type: "real", values: queryRepr, D });
+    for (const idx of indicesToSearch) {
+      const record = this.recordsList[idx];
+      const sSem = this._cosineSimilarity(queryRepr, record.representation);
+      const specRecord = record.spectralTransform || (record.spectralTransform = this.spectral.spectralTransform({ type: "real", values: record.representation, D }));
+      const sRes = this.spectral.spectralSimilarity(specQuery, specRecord);
+      const C = this.getDecayedConfidence(record, currentTime);
+      const F = Math.min(1, Math.log10(record.reinforcement + 1));
+      const D_penalty = record.confidence - C;
+      const X = record.status === "conflicted" || record.contradictionIds.length > 0 ? 1 : 0;
+      const score = this.ws * sSem + this.wr * sRes + this.wc * C + this.wf * F - this.wd * D_penalty - this.wx * X;
+      results.push({ record, score });
+    }
+    results.sort((a, b) => b.score - a.score);
+    const sliced = results.slice(0, limit);
+    for (const item of sliced) {
+      item.record.lastAccessedAt = currentTime;
+    }
+    return sliced.map((item) => ({
+      record: item.record,
+      score: item.score
+    }));
+  }
+  /**
+   * Non-blocking debounced save to file system
+   * @param {string} filePath
+   */
+  saveToFile(filePath) {
+    if (this._saveTimeout) clearTimeout(this._saveTimeout);
+    const data = [];
+    for (const record of this.recordsList) {
+      data.push({
+        id: record.id,
+        representation: Array.from(record.representation),
+        content: record.content,
+        confidence: record.confidence,
+        reinforcement: record.reinforcement,
+        createdAt: record.createdAt,
+        lastAccessedAt: record.lastAccessedAt,
+        lastReinforcedAt: record.lastReinforcedAt,
+        source: record.source,
+        sourceType: record.sourceType,
+        status: record.status,
+        contradictionIds: record.contradictionIds
+      });
+    }
+    this._savePromise = new Promise((resolve) => {
+      this._saveTimeout = setTimeout(async () => {
+        try {
+          await fs.promises.writeFile(filePath, JSON.stringify(data, null, 2), "utf8");
+        } catch (e) {
+          console.error("MemoryEngine: Asynchronous write failed:", e.message);
+        }
+        resolve();
+      }, 50);
+    });
+  }
+  /**
+   * Load memory records synchronously and rebuild LSH tables
+   * @param {string} filePath
+   */
+  loadFromFile(filePath) {
+    if (!fs.existsSync(filePath)) return;
+    try {
+      const raw = fs.readFileSync(filePath, "utf8");
+      const data = JSON.parse(raw);
+      this.records.clear();
+      this.recordsList = [];
+      this.tablesProjections = null;
+      this.tablesBuckets = null;
+      for (const item of data) {
+        this.addRecord({
+          id: item.id,
+          representation: new Float32Array(item.representation),
+          content: item.content,
+          confidence: item.confidence,
+          reinforcement: item.reinforcement,
+          createdAt: item.createdAt,
+          lastAccessedAt: item.lastAccessedAt,
+          lastReinforcedAt: item.lastReinforcedAt,
+          source: item.source,
+          sourceType: item.sourceType,
+          status: item.status,
+          contradictionIds: item.contradictionIds
+        });
+      }
+    } catch (e) {
+      console.error("MemoryEngine: Failed to load from file:", e.message);
+    }
+  }
+  _cosineSimilarity(a, b) {
+    let sum = 0;
+    const D = a.length;
+    for (let i = 0; i < D; i++) {
+      sum += Math.cos(a[i] - b[i]);
+    }
+    return sum / D;
+  }
+  _checkAndFlagContradictions(record) {
+    if (this.recordsList.length <= 1) return;
+    const existingResults = this.retrieve(record.representation, 3);
+    for (const existing of existingResults) {
+      const sim = this._cosineSimilarity(record.representation, existing.record.representation);
+      const isContra = this._isContradictory(record.content, existing.record.content);
+      if (sim > 0.35 && existing.record.id !== record.id && existing.record.content !== record.content) {
+        if (isContra) {
+          this.flagContradiction(record.id, existing.record.id);
+        }
+      }
+    }
+  }
+  _isContradictory(t1, t2) {
+    const getBloodType = (t) => {
+      if (t.includes("a pozitif") || t.includes("a+") || t.includes("a poz")) return "A+";
+      if (t.includes("b negatif") || t.includes("b-") || t.includes("b neg")) return "B-";
+      if (t.includes("0") || t.includes("s\u0131f\u0131r")) return "0";
+      if (t.includes("ab")) return "AB";
+      return null;
+    };
+    const getRisk = (t) => {
+      if (t.includes("y\xFCksek") || t.includes("riskli")) return "high";
+      if (t.includes("normal") || t.includes("d\xFC\u015F\xFCk") || t.includes("risk yok")) return "normal";
+      return null;
+    };
+    const l1 = t1.toLowerCase();
+    const l2 = t2.toLowerCase();
+    if ((l1.includes("kan grubu") || l1.includes("grubu")) && (l2.includes("kan grubu") || l2.includes("grubu"))) {
+      const b1 = getBloodType(l1);
+      const b2 = getBloodType(l2);
+      if (b1 && b2 && b1 !== b2) return true;
+    }
+    if (l1.includes("risk") && l2.includes("risk")) {
+      const r1 = getRisk(l1);
+      const r2 = getRisk(l2);
+      if (r1 && r2 && r1 !== r2) return true;
+    }
+    if ((l1.includes("tansiyon") || l1.includes("bas\u0131nc\u0131")) && (l2.includes("tansiyon") || l2.includes("bas\u0131nc\u0131"))) {
+      const nums1 = l1.match(/\d+/g);
+      const nums2 = l2.match(/\d+/g);
+      if (nums1 && nums2 && nums1[0] !== nums2[0]) return true;
+    }
+    return false;
+  }
+  resolveConflict(winnerId, loserId) {
+    const winner = this.records.get(winnerId);
+    const loser = this.records.get(loserId);
+    if (winner) {
+      const t = Date.now();
+      const currentC = this.getDecayedConfidence(winner, t);
+      winner.confidence = Math.min(1, currentC + 0.3 * (1 - currentC));
+      winner.status = "active";
+      winner.contradictionIds = [];
+      winner.lastReinforcedAt = t;
+    }
+    if (loser) {
+      loser.confidence = 0;
+      loser.status = "rejected";
+      loser.contradictionIds = [];
+    }
+  }
+};
+
+// core/reasoning_router.js
+function evaluateMath(expr) {
+  const tokens = [];
+  let i = 0;
+  while (i < expr.length) {
+    const char = expr[i];
+    if (/\s/.test(char)) {
+      i++;
+      continue;
+    }
+    if (/[0-9.]/.test(char)) {
+      let numStr = "";
+      while (i < expr.length && /[0-9.]/.test(expr[i])) {
+        numStr += expr[i];
+        i++;
+      }
+      tokens.push({ type: "NUMBER", value: parseFloat(numStr) });
+      continue;
+    }
+    if (char === "+" || char === "-" || char === "*" || char === "/" || char === "%" || char === "^" || char === "(" || char === ")") {
+      tokens.push({ type: "OP", value: char });
+      i++;
+      continue;
+    }
+    throw new Error("Invalid character in math expression: " + char);
+  }
+  let tokenIndex = 0;
+  function peek() {
+    return tokens[tokenIndex];
+  }
+  function consume(expectedValue) {
+    const t = tokens[tokenIndex];
+    if (!t) throw new Error("Unexpected end of expression");
+    if (expectedValue !== void 0 && t.value !== expectedValue) {
+      throw new Error(`Expected ${expectedValue} but got ${t.value}`);
+    }
+    tokenIndex++;
+    return t;
+  }
+  function parseExpression() {
+    let val = parseTerm();
+    while (true) {
+      const t = peek();
+      if (t && t.type === "OP" && (t.value === "+" || t.value === "-")) {
+        consume();
+        const nextVal = parseTerm();
+        if (t.value === "+") val += nextVal;
+        else val -= nextVal;
+      } else {
+        break;
+      }
+    }
+    return val;
+  }
+  function parseTerm() {
+    let val = parseFactor();
+    while (true) {
+      const t = peek();
+      if (t && t.type === "OP" && (t.value === "*" || t.value === "/" || t.value === "%")) {
+        consume();
+        const nextVal = parseFactor();
+        if (t.value === "*") val *= nextVal;
+        else if (t.value === "/") {
+          if (nextVal === 0) throw new Error("Division by zero");
+          val /= nextVal;
+        } else val %= nextVal;
+      } else {
+        break;
+      }
+    }
+    return val;
+  }
+  function parseFactor() {
+    let val = parsePrimary();
+    while (true) {
+      const t = peek();
+      if (t && t.type === "OP" && t.value === "^") {
+        consume();
+        const nextVal = parseFactor();
+        val = Math.pow(val, nextVal);
+      } else {
+        break;
+      }
+    }
+    return val;
+  }
+  function parsePrimary() {
+    const t = peek();
+    if (!t) throw new Error("Unexpected end of expression");
+    if (t.type === "NUMBER") {
+      consume();
+      return t.value;
+    }
+    if (t.type === "OP" && t.value === "(") {
+      consume("(");
+      const val = parseExpression();
+      consume(")");
+      return val;
+    }
+    if (t.type === "OP" && t.value === "-") {
+      consume("-");
+      return -parsePrimary();
+    }
+    if (t.type === "OP" && t.value === "+") {
+      consume("+");
+      return parsePrimary();
+    }
+    throw new Error(`Unexpected token: ${t.value}`);
+  }
+  const result = parseExpression();
+  if (tokenIndex < tokens.length) {
+    throw new Error("Unexpected trailing tokens at end of expression");
+  }
+  return result;
+}
+var ReasoningRouter = class {
+  /**
+   * @param {Object} memoryEngine
+   * @param {Object} sdkInstance
+   */
+  constructor(memoryEngine, sdkInstance) {
+    this.memory = memoryEngine;
+    this.sdk = sdkInstance;
+    this.D = sdkInstance ? sdkInstance.D : 4096;
+    if (this.sdk && this.sdk.hdc) {
+      const memReps = ["hat\u0131rla", "hat\u0131rl\u0131yor", "favori", "nerede", "kim", "haf\u0131za", "hasta", "kay\u0131t", "bilgi", "durum"].map((w) => this.sdk.hdc.generateSeeded("complex", w));
+      this.memoryIntentVec = this.sdk.hdc.bundle(memReps).values;
+      const ruleReps = ["\xE7eli\u015Fki", "kural", "kar\u015F\u0131la\u015Ft\u0131r", "do\u011Fru", "yasak", "uygun"].map((w) => this.sdk.hdc.generateSeeded("complex", w));
+      this.ruleIntentVec = this.sdk.hdc.bundle(ruleReps).values;
+      const mathReps = ["hesapla", "toplam", "\xE7arp", "b\xF6l", "ka\xE7", "say\u0131", "doz", "miktar"].map((w) => this.sdk.hdc.generateSeeded("complex", w));
+      this.mathIntentVec = this.sdk.hdc.bundle(mathReps).values;
+    } else {
+      this.memoryIntentVec = new Float32Array(this.D);
+      this.ruleIntentVec = new Float32Array(this.D);
+      this.mathIntentVec = new Float32Array(this.D);
+    }
+    this.chatState = "idle";
+    this.pendingRecord = null;
+  }
+  /**
+   * Self-vectorize text input using SDK's HDC engine (runs in < 0.1 ms)
+   * @param {string} text
+   * @returns {Float32Array}
+   */
+  vectorize(text) {
+    const clean = text.toLowerCase().trim().replace(/[^a-zçgğıoöşuüâîû\s]/g, "");
+    const words = clean.split(/\s+/).filter(Boolean);
+    if (this.sdk && this.sdk.hdc) {
+      if (words.length === 0) {
+        return new Float32Array(this.D);
+      }
+      if (words.length === 1) {
+        return this.sdk.hdc.generateSeeded("complex", words[0]).values;
+      }
+      const reps = words.map((w) => this.sdk.hdc.generateSeeded("complex", w));
+      return this.sdk.hdc.bundle(reps).values;
+    }
+    return new Float32Array(this.D);
+  }
+  /**
+   * 8-Axis Verification Suite
+   * @param {Object} result - Candidate routed result
+   * @param {number} axis - Axis index [1-8]
+   * @returns {boolean} True if pass
+   */
+  validateAxis(result, axis) {
+    if (!result) return false;
+    if (axis === 1 && result.route === "math") {
+      const match = result.input.match(/^\s*([0-9.]+)\s*([+\-*/%^])\s*([0-9.]+)\s*$/);
+      if (match) {
+        const a = parseFloat(match[1]);
+        const op = match[2];
+        const b = parseFloat(match[3]);
+        const c = parseFloat(result.output);
+        if (op === "*") {
+          if (b !== 0 && Math.abs(c / b - a) > 1e-4) return false;
+        } else if (op === "+") {
+          if (Math.abs(c - b - a) > 1e-4) return false;
+        } else if (op === "-") {
+          if (Math.abs(c + b - a) > 1e-4) return false;
+        } else if (op === "/") {
+          if (b !== 0 && Math.abs(c * b - a) > 1e-4) return false;
+        }
+      }
+      return true;
+    }
+    if (axis === 2 && result.route === "math") {
+      const val = parseFloat(result.output);
+      if (isNaN(val) || !isFinite(val)) return false;
+      if (result.input.includes("/0")) return false;
+      return true;
+    }
+    if (axis === 3 && result.route === "memory") {
+      if (!result.results || result.results.length === 0) return false;
+      const topRecord = result.results[0].record;
+      if (topRecord.status === "conflicted" || topRecord.contradictionIds.length > 0) {
+        return false;
+      }
+      return true;
+    }
+    if (axis === 4 && result.route === "memory") {
+      if (!result.results || result.results.length === 0) return false;
+      const topRecord = result.results[0].record;
+      const C = this.memory.getDecayedConfidence(topRecord);
+      if (C < 0.5) return false;
+      return true;
+    }
+    if (axis === 5 && result.route === "memory") {
+      if (!result.results || result.results.length === 0) return false;
+      const queryVec = this.vectorize(result.input);
+      const sSem = this._cosineSimilarity(queryVec, result.results[0].record.representation);
+      if (sSem < 0.15) return false;
+      return true;
+    }
+    if (axis === 6 && (result.route === "llm" || result.route === "memory")) {
+      if (this.sdk && this.sdk.morphology) {
+        const words = result.output.split(/\s+/).filter(Boolean);
+        for (const w of words) {
+          const cleanWord = w.toLowerCase().replace(/[^a-zçgğıoöşuüâîû]/g, "");
+          if (cleanWord.length >= 2) {
+            const harmony = this.sdk.morphology.determineVowelHarmony(cleanWord);
+            if (harmony !== "front" && harmony !== "back") return false;
+          }
+        }
+      }
+      return true;
+    }
+    if (axis === 7 && result.route === "llm") {
+      const words = result.output.split(/\s+/).filter(Boolean);
+      for (const w of words) {
+        const clean = w.toLowerCase().replace(/[^a-zçgğıoöşuüâîû]/g, "");
+        if (/(kitapı|bebeki|çiçeki|ağacı)/.test(clean)) return false;
+      }
+      return true;
+    }
+    if (axis === 8 && result.route === "memory") {
+      const queryWords = result.input.toLowerCase().split(/\s+/).filter((w) => w.length > 3);
+      const contentLower = result.output.toLowerCase();
+      if (queryWords.length > 0) {
+        const matchesQueryWord = queryWords.some((qw) => contentLower.includes(qw));
+        if (!matchesQueryWord) return false;
+      }
+      return true;
+    }
+    return true;
+  }
+  /**
+   * Run all 8 verification axes
+   */
+  validateAllAxes(result) {
+    for (let axis = 1; axis <= 8; axis++) {
+      if (!this.validateAxis(result, axis)) return false;
+    }
+    return true;
+  }
+  /**
+   * Route the query dynamically using safe parser, self-vectorization, and hybrid classification
+   * @param {string} input
+   * @returns {Object} Route result
+   */
+  route(input, options = {}) {
+    const cleanInput = input.trim();
+    const saveIntentRegex = /kaydet|ekle|yaz|not al|sakla|sisteme gir|oluştur/i;
+    const confirmRegex = /^(evet|tamam|doğru|olur|kaydet|kabul|onay|evet kaydet)$/i;
+    const rejectRegex = /^(hayır|iptal|vazgeç|yanlış|dur|bekle)$/i;
+    if (this.chatState === "pending_confirmation") {
+      if (confirmRegex.test(cleanInput)) {
+        this.chatState = "recording";
+        const r = this.pendingRecord;
+        const searchableText = [r.baslik, r.kategori, r.aciklama, r.etiketler].filter(Boolean).join(" ");
+        const representation = this.vectorize(searchableText);
+        const newRecord = this.memory.addRecord({
+          content: `${r.baslik} \u2014 ${r.aciklama}`,
+          representation,
+          priority: "normal"
+        });
+        this.chatState = "idle";
+        this.pendingRecord = null;
+        return {
+          input: cleanInput,
+          route: "memory",
+          llmBypassed: true,
+          output: "Haf\u0131za kayd\u0131 ba\u015Far\u0131yla eklendi.",
+          reason: "Chat state machine confirm and record"
+        };
+      } else if (rejectRegex.test(cleanInput)) {
+        this.chatState = "idle";
+        this.pendingRecord = null;
+        return {
+          input: cleanInput,
+          route: "memory",
+          llmBypassed: true,
+          output: "Kay\u0131t iptal edildi.",
+          reason: "Chat state machine reject"
+        };
+      } else {
+        this.chatState = "idle";
+        this.pendingRecord = null;
+        const normalResult = this._routeNormal(input, options);
+        normalResult.output = "\xD6nceki kayd\u0131 iptal ettim. " + normalResult.output;
+        return normalResult;
+      }
+    }
+    if (this.chatState === "idle" && saveIntentRegex.test(cleanInput)) {
+      const data = this._extractDataFromText(cleanInput);
+      if (data.baslik && data.aciklama) {
+        this.chatState = "pending_confirmation";
+        this.pendingRecord = data;
+        return {
+          input: cleanInput,
+          route: "memory",
+          llmBypassed: true,
+          output: `\u015Eunu kaydediyorum:
+  Ba\u015Fl\u0131k: ${data.baslik}
+  Not: ${data.aciklama}
+Do\u011Fru mu?`,
+          reason: "Chat state machine save intent detected"
+        };
+      }
+    }
+    return this._routeNormal(input, options);
+  }
+  _extractDataFromText(text) {
+    const clean = text.replace(/kaydet|ekle|yaz|not al|sakla|sisteme gir|oluştur/ig, "").trim();
+    const parts = clean.split(",").map((p) => p.trim()).filter(Boolean);
+    let baslik = "";
+    let aciklama = "";
+    let kategori = "";
+    let etiketler = "";
+    if (parts.length >= 2) {
+      baslik = parts[0];
+      aciklama = parts[1];
+      if (parts.length >= 3) kategori = parts[2];
+      if (parts.length >= 4) etiketler = parts.slice(3).join(", ");
+    } else {
+      const words = clean.split(/\s+/);
+      if (words.length > 2) {
+        baslik = words.slice(0, 2).join(" ");
+        aciklama = words.slice(2).join(" ");
+      } else {
+        baslik = clean;
+        aciklama = clean;
+      }
+    }
+    baslik = baslik.replace(/[,.;!]+$/, "").trim();
+    aciklama = aciklama.replace(/[,.;!]+$/, "").trim();
+    if (!baslik) baslik = clean || "Yeni Kay\u0131t";
+    if (!aciklama) aciklama = clean || "Detay girilmedi";
+    return { baslik, aciklama, kategori, etiketler };
+  }
+  _routeNormal(input, options = {}) {
+    const cleanInput = input.trim();
+    const mathRegex = /^[0-9+\-*/().\s%^]+$/;
+    const hasOperator = /[+\-*/%^]/.test(cleanInput);
+    if (mathRegex.test(cleanInput) && hasOperator) {
+      try {
+        const val = evaluateMath(cleanInput);
+        const candidateResult = {
+          input: cleanInput,
+          route: "math",
+          llmBypassed: true,
+          output: val.toString(),
+          reason: "Deterministic arithmetic evaluation"
+        };
+        if (this.validateAllAxes(candidateResult)) {
+          return candidateResult;
+        } else {
+          return {
+            input: cleanInput,
+            route: "math",
+            llmBypassed: true,
+            output: "Hata: Ge\xE7ersiz aritmetik i\u015Flem (S\u0131f\u0131ra b\xF6lme veya tan\u0131ms\u0131z sonu\xE7)",
+            reason: "Math verifier failure recovery"
+          };
+        }
+      } catch (e) {
+      }
+    }
+    const queryVec = this.vectorize(cleanInput);
+    const memorySimilarity = this._cosineSimilarity(queryVec, this.memoryIntentVec);
+    const ruleSimilarity = this._cosineSimilarity(queryVec, this.ruleIntentVec);
+    const memoryRegex = /hatırlıyor\s*musun|benim\s*favori|nerede|hatırla|kayıt|hasta|durumu|kaydı|geçmiş|bilgi|var\s*mı|söyle|kim|yaşı|şikayeti|tanı|ilaç|doz|kan\s*grubu|risk|gebelik|diyabet|tansiyon|unuttun|hâlâ|güncelle|seviye|ölçüm|ne\s*zaman|değişti|sonuç|nedir|kaydı\s*var/i;
+    const ruleRegex = /çelişki|kural|karşılaştır|doğru\s*mu|yasak|uygun/i;
+    if (memoryRegex.test(cleanInput) || memorySimilarity > 0.18) {
+      const results = this.memory ? this.memory.retrieve(queryVec, 5) : [];
+      console.log(`[Router DBG] Memory triggered. Query: "${cleanInput}". Results count: ${results.length}`);
+      if (results.length > 0) {
+        console.log(`[Router DBG] Candidate list:`);
+        results.forEach((res, i) => {
+          const sSem = this._cosineSimilarity(queryVec, res.record.representation);
+          console.log(`  #${i}: "${res.record.content}" | score: ${res.score.toFixed(4)} | sSem: ${sSem.toFixed(4)} | status: ${res.record.status}`);
+        });
+        let conflictedResult = null;
+        for (const res of results) {
+          const sim = this._cosineSimilarity(queryVec, res.record.representation);
+          if (sim > 0.15 && (res.record.status === "conflicted" || res.record.contradictionIds.length > 0)) {
+            conflictedResult = res.record;
+            break;
+          }
+        }
+        if (conflictedResult) {
+          const conflictRecords = [conflictedResult];
+          for (const cId of conflictedResult.contradictionIds) {
+            const cRec = this.memory.records.get(cId);
+            if (cRec) conflictRecords.push(cRec);
+          }
+          const conflictSummary = conflictRecords.map((r) => r.content).join(" | ");
+          console.log(`[Router DBG] Contradiction detected!`);
+          return {
+            input: cleanInput,
+            route: "memory",
+            llmBypassed: true,
+            output: `\xC7eli\u015Fen kay\u0131tlar tespit edildi: ${conflictSummary}. L\xFCtfen do\u011Fru olan\u0131 belirtin.`,
+            conflict: {
+              detected: true,
+              records: conflictRecords.map((r) => ({ id: r.id, content: r.content, confidence: this.memory.getDecayedConfidence(r) })),
+              message: "Bu kay\u0131tta \xE7eli\u015Fen bilgi var. L\xFCtfen do\u011Fru olan\u0131 belirtin."
+            },
+            results: results.slice(0, 3),
+            reason: "Contradiction detected in memory"
+          };
+        }
+        const candidate = {
+          input: cleanInput,
+          route: "memory",
+          llmBypassed: true,
+          output: results[0].record.content,
+          results: [results[0]],
+          reason: "Semantic memory query candidate"
+        };
+        const isValid = this.validateAllAxes(candidate);
+        console.log(`[Router DBG] Candidate isValid: ${isValid}`);
+        if (!isValid) {
+          for (let axis = 1; axis <= 8; axis++) {
+            console.log(`  Axis ${axis}: ${this.validateAxis(candidate, axis)}`);
+          }
+        }
+        if (isValid) {
+          return candidate;
+        } else {
+          for (let i = 1; i < results.length; i++) {
+            const nextCandidate = {
+              input: cleanInput,
+              route: "memory",
+              llmBypassed: true,
+              output: results[i].record.content,
+              results: [results[i]],
+              reason: "Replan candidate"
+            };
+            if (this.validateAllAxes(nextCandidate)) {
+              console.log(`[Router DBG] Replan candidate ${i} is valid.`);
+              return nextCandidate;
+            }
+          }
+          return {
+            input: cleanInput,
+            route: "memory",
+            llmBypassed: true,
+            output: "Bu bilgi haf\u0131zada bulunamad\u0131. Hen\xFCz kay\u0131t edilmemi\u015F olabilir.",
+            results: [],
+            reason: "Memory candidates failed validation (low similarity)"
+          };
+        }
+      } else {
+        return {
+          input: cleanInput,
+          route: "memory",
+          llmBypassed: true,
+          output: "Bu bilgi haf\u0131zada bulunamad\u0131. Hen\xFCz kay\u0131t edilmemi\u015F olabilir.",
+          results: [],
+          reason: "Memory triggered but empty"
+        };
+      }
+    }
+    if (ruleRegex.test(cleanInput) || ruleSimilarity > 0.28) {
+      return {
+        route: "rules",
+        llmBypassed: true,
+        output: "Kural de\u011Ferlendirmesi bilgi graf\u0131 / kural katman\u0131na aktar\u0131ld\u0131.",
+        reason: `Rule structure detected (Match Sim: ${ruleSimilarity.toFixed(4)})`
+      };
+    }
+    const mathSimilarity = this._cosineSimilarity(queryVec, this.mathIntentVec);
+    const allSimilarities = [
+      mathSimilarity,
+      memorySimilarity,
+      ruleSimilarity
+    ];
+    const maxSimilarity = Math.max(...allSimilarities);
+    if (maxSimilarity < 0.12) {
+      return {
+        input: cleanInput,
+        route: "boundary",
+        output: "Bu konuda bilgim yok. Ba\u015Fka bir konuda yard\u0131mc\u0131 olabilir miyim?",
+        llmBypassed: true,
+        confidence: maxSimilarity,
+        reason: `Capability boundary \u2014 no intent matched (max similarity: ${maxSimilarity.toFixed(4)})`
+      };
+    }
+    let outputText = "";
+    let sdkResult = null;
+    if (this.sdk && typeof this.sdk.generate === "function") {
+      sdkResult = this.sdk.generate(cleanInput, {
+        temperature: options.temperature !== void 0 ? options.temperature : 0,
+        maxLength: options.maxLength !== void 0 ? options.maxLength : this.sdk.maxLength
+      });
+      outputText = sdkResult.generatedText;
+    } else {
+      outputText = `[SLM Fallback] ${cleanInput}`;
+    }
+    const candidateGenResult = {
+      input: cleanInput,
+      route: "llm",
+      llmBypassed: false,
+      output: outputText,
+      sdkResult,
+      reason: "Generative language synthesis required"
+    };
+    if (this.validateAllAxes(candidateGenResult)) {
+      return candidateGenResult;
+    }
+    candidateGenResult.output = `${outputText}.`;
+    return candidateGenResult;
+  }
+  _cosineSimilarity(a, b) {
+    let sum = 0;
+    const D = a.length;
+    for (let i = 0; i < D; i++) {
+      sum += Math.cos(a[i] - b[i]);
+    }
+    return sum / D;
+  }
+};
+
+// core/sovereign_agent.js
+var SovereignAgent = class {
+  /**
+   * @param {Object} sdkInstance - The ResonanceSDK instance containing hdc, memory, router, morphology
+   */
+  constructor(sdkInstance) {
+    this.sdk = sdkInstance;
+    this.memory = sdkInstance ? sdkInstance.memory : null;
+    this.morphology = sdkInstance ? sdkInstance.morphology : null;
+    this.router = sdkInstance ? sdkInstance.router : null;
+    this.tools = {
+      memory_lookup: (query) => {
+        if (!this.memory) return "Hata: Bellek motoru y\xFCkl\xFC de\u011Fil.";
+        const vec = this.router ? this.router.vectorize(query) : new Float32Array(1024);
+        const results = this.memory.retrieve(vec, 1);
+        if (results.length === 0) return "Bulunamad\u0131.";
+        return results[0].record.content;
+      },
+      math_eval: (expr) => {
+        try {
+          return evaluateMath(expr).toString();
+        } catch (e) {
+          return `Hata: Matematiksel hesaplama ba\u015Far\u0131s\u0131z. ${e.message}`;
+        }
+      },
+      morphology_analyze: (word) => {
+        if (!this.morphology) return "Hata: Morfoloji motoru y\xFCkl\xFC de\u011Fil.";
+        const analysis = this.morphology.analyze(word);
+        return JSON.stringify({
+          root: analysis.root,
+          suffixes: analysis.suffixes,
+          harmony: analysis.harmony,
+          syllables: analysis.syllables
+        });
+      },
+      spectral_transform: (text) => {
+        if (!this.sdk || !this.sdk.spectral) return "Hata: Spektral motor y\xFCkl\xFC de\u011Fil.";
+        const vec = this.router ? this.router.vectorize(text) : new Float32Array(1024);
+        const spec = this.sdk.spectral.spectralTransform({ type: "real", values: vec, D: vec.length });
+        return `Energy: ${spec.magnitude.reduce((a, b) => a + b, 0).toFixed(2)}`;
+      },
+      system_time: () => {
+        return (/* @__PURE__ */ new Date()).toISOString();
+      }
+    };
+  }
+  /**
+   * Run the ReAct autonomous execution loop
+   * @param {string} goal - The user prompt/objective
+   * @param {number} [maxSteps=5] - Maximum execution steps
+   * @returns {Promise<Object>} Execution log and final answer
+   */
+  async execute(goal, maxSteps = 5) {
+    const logs = [];
+    let step = 1;
+    let finished = false;
+    let finalAnswer = "";
+    const lowerGoal = goal.toLowerCase();
+    while (step <= maxSteps && !finished) {
+      let thought = "";
+      let action = "";
+      let actionArg = "";
+      if (lowerGoal.includes("hat\u0131rla") || lowerGoal.includes("haf\u0131za") || lowerGoal.includes("favori")) {
+        if (step === 1) {
+          thought = "Kullan\u0131c\u0131n\u0131n sordu\u011Fu favori veya bellek kayd\u0131n\u0131 bulmak i\xE7in haf\u0131zada arama yapmal\u0131y\u0131m.";
+          action = "memory_lookup";
+          actionArg = lowerGoal.includes("renk") ? "favori renk" : "haf\u0131za sorgusu";
+        } else if (step === 2) {
+          const prevObs = logs[0].observation;
+          thought = `Haf\u0131zadan '${prevObs}' bilgisini ald\u0131m. Bu kelimeyi morfolojik olarak analiz etmeliyim.`;
+          action = "morphology_analyze";
+          actionArg = prevObs.split(/\s+/).pop().replace(/[^a-zçgğıoöşuüâîû]/g, "");
+        } else {
+          const prevObs = logs[1].observation;
+          thought = "Gerekli aramalar\u0131 ve analizleri tamamlad\u0131m. Sonucu kullan\u0131c\u0131ya sunuyorum.";
+          finished = true;
+          finalAnswer = `Otonom ReAct G\xF6revi Ba\u015Far\u0131yla Tamamland\u0131.
+- Haf\u0131za Kayd\u0131: ${logs[0].observation}
+- Morfolojik Yap\u0131: ${prevObs}`;
+        }
+      } else if (lowerGoal.includes("hesapla") || /[0-9+\-*/%^]/.test(lowerGoal)) {
+        if (step === 1) {
+          thought = "Matematiksel ifadeyi deterministik parser ile hesaplamal\u0131y\u0131m.";
+          action = "math_eval";
+          const match = goal.match(/[0-9+\-*/%^().\s]+/);
+          actionArg = match ? match[0].trim() : "0";
+        } else if (step === 2) {
+          const val = logs[0].observation;
+          thought = `Hesaplanan '${val}' sonucunun spektral enerji yo\u011Funlu\u011Funu kontrol etmeliyim.`;
+          action = "spectral_transform";
+          actionArg = val;
+        } else {
+          thought = "Hesaplama ve spektral d\xF6n\xFC\u015F\xFCm ad\u0131mlar\u0131 bitti. Sonucu d\xF6n\xFCyorum.";
+          finished = true;
+          finalAnswer = `Hesaplama Sonucu: ${logs[0].observation} | Spektral Temsiliyet: ${logs[1].observation}`;
+        }
+      } else {
+        if (step === 1) {
+          thought = "Sistem saatini alarak g\xFCncel zaman\u0131 kontrol etmeliyim.";
+          action = "system_time";
+          actionArg = "";
+        } else {
+          thought = "Varsay\u0131lan otonom ak\u0131\u015F tamamland\u0131.";
+          finished = true;
+          finalAnswer = `Mevcut Zaman Dilimi: ${logs[0].observation}`;
+        }
+      }
+      if (!finished) {
+        let observation = "";
+        const toolFn = this.tools[action];
+        if (toolFn) {
+          observation = toolFn(actionArg);
+        } else {
+          observation = `Hata: '${action}' arac\u0131 tan\u0131ml\u0131 de\u011Fil.`;
+        }
+        logs.push({
+          step,
+          thought,
+          action,
+          argument: actionArg,
+          observation
+        });
+        step++;
+      } else {
+        logs.push({
+          step,
+          thought,
+          action: "final_answer",
+          argument: "",
+          observation: finalAnswer
+        });
+      }
+    }
+    return {
+      goal,
+      stepsRun: step - 1,
+      logs,
+      finalAnswer
+    };
+  }
+};
+
+// sdk/resonance_sdk.js
+function generateDerivations(root, morphology) {
+  const harmony = morphology.determineVowelHarmony(root);
+  const lastChar = root[root.length - 1];
+  const isVowel = morphology.allVowels.has(lastChar);
+  const derivations = [root];
+  const hardConsonants = /* @__PURE__ */ new Set(["t", "k", "\xE7", "p", "s", "\u015F", "h", "f"]);
+  const isHard = hardConsonants.has(lastChar);
+  const mutateRoot = (r, suffix) => {
+    if (!suffix) return r;
+    const startsWithVowel = morphology.allVowels.has(suffix[0]);
+    if (startsWithVowel) {
+      const last = r[r.length - 1];
+      let mutated = r.slice(0, -1);
+      if (last === "p") return mutated + "b" + suffix;
+      if (last === "\xE7") return mutated + "c" + suffix;
+      if (last === "t") return mutated + "d" + suffix;
+      if (last === "k") {
+        if (r === "renk") return mutated + "g" + suffix;
+        return mutated + "\u011F" + suffix;
+      }
+    }
+    return r + suffix;
+  };
+  if (harmony === "front") {
+    derivations.push(root + "ler");
+    derivations.push(isVowel ? root + "nin" : mutateRoot(root, "in"));
+    derivations.push(isVowel ? root + "ye" : mutateRoot(root, "e"));
+    derivations.push(isVowel ? root + "yi" : mutateRoot(root, "i"));
+    derivations.push(root + (isHard ? "te" : "de"));
+    derivations.push(root + (isHard ? "ten" : "den"));
+    derivations.push(isVowel ? root + "m" : mutateRoot(root, "im"));
+  } else {
+    derivations.push(root + "lar");
+    derivations.push(isVowel ? root + "n\u0131n" : mutateRoot(root, "\u0131n"));
+    derivations.push(isVowel ? root + "ya" : mutateRoot(root, "a"));
+    derivations.push(isVowel ? root + "y\u0131" : mutateRoot(root, "\u0131"));
+    derivations.push(root + (isHard ? "ta" : "da"));
+    derivations.push(root + (isHard ? "tan" : "dan"));
+    derivations.push(isVowel ? root + "m" : mutateRoot(root, "\u0131m"));
+  }
+  return derivations;
+}
+var ResonanceSDK = class {
+  /**
+   * @param {Object} config - SDK configuration
+   * @param {number} [config.D=4096] - Hyperdimensional vector dimension
+   * @param {number} [config.temperature=0.7] - Default sampling temperature
+   * @param {number} [config.maxLength=10] - Default max generation length
+   */
+  constructor(config = {}) {
+    this.D = config.D || 4096;
+    this.hdc = new HDCEngine(this.D);
+    this.morphology = new TurkishMorphology();
+    this.spectral = new SpectralEngine();
+    this.memory = new MemoryEngine(config.memory || {});
+    this.router = new ReasoningRouter(this.memory, this);
+    this.temperature = config.temperature !== void 0 ? config.temperature : 0.7;
+    this.maxLength = config.maxLength || 10;
+    this.vocab = [];
+    this.vocabMap = /* @__PURE__ */ new Map();
+    this.embeddings = /* @__PURE__ */ new Map();
+    this.wordCounts = /* @__PURE__ */ new Map();
+    this.freqIndices = [];
+    this.wordDerivationIndices = /* @__PURE__ */ new Map();
+    this.transitionCounts = /* @__PURE__ */ new Map();
+    this.sparseWeightsSpec = null;
+    this.wasmInstance = null;
+    this.wasmMemory = null;
+    this.vocabCosPtr = 0;
+    this.vocabSinPtr = 0;
+    this.scoresPtr = 0;
+    this.candidateIndicesPtr = 0;
+    this._initialized = false;
+    this._runtime = typeof window !== "undefined" ? "browser" : "node";
+  }
+  // ── PUBLIC API ──────────────────────────────────────────────
+  /**
+   * Initialize the SDK. Must be called before generate() or analyze().
+   * @param {Object} [options]
+   * @param {ArrayBuffer} [options.wasmBinary] - Pre-loaded WASM binary buffer
+   * @param {string} [options.wasmUrl] - URL to fetch WASM (browser mode)
+   * @param {string} [options.wasmPath] - File path to WASM (Node.js mode)
+   * @param {string} [options.corpusUrl] - URL to tr_corpus_embed.js (browser mode)
+   * @param {string} [options.corpusPath] - File path to tr_corpus_embed.js (Node.js mode)
+   */
+  async init(options = {}) {
+    if (this._initialized) return;
+    await this._loadWasm(options);
+    await this._buildVocabulary(options);
+    this._initialized = true;
+  }
+  /**
+   * Generate text autoregressively from a prompt.
+   * @param {string} prompt - Input Turkish text prompt
+   * @param {Object} [options]
+   * @param {number} [options.maxLength] - Override default max tokens
+   * @param {number} [options.temperature] - Override default temperature
+   * @param {function} [options.onToken] - Streaming callback: (word, step) => void
+   * @returns {Object} { prompt, generatedText, newTokens, steps, totalLatencyMs, finishReason, vocabSize }
+   */
+  generate(prompt, options = {}) {
+    this._assertInit();
+    const maxLen = options.maxLength || this.maxLength;
+    const temp = options.temperature !== void 0 ? options.temperature : this.temperature;
+    const onToken = options.onToken || null;
+    const cleanPrompt = this.morphology.normalize(prompt);
+    const tokens = cleanPrompt.split(/\s+/).filter(Boolean);
+    if (tokens.length === 0) tokens.push("ev");
+    const promptLength = tokens.length;
+    const steps = [];
+    let stopReason = "length";
+    const startTime = performance.now();
+    for (let step = 0; step < maxLen; step++) {
+      const stepStart = performance.now();
+      const nextObj = this._predictNext(tokens, temp, promptLength);
+      const stepEnd = performance.now();
+      tokens.push(nextObj.word);
+      const stepInfo = { word: nextObj.word, score: nextObj.score, latencyMs: stepEnd - stepStart };
+      steps.push(stepInfo);
+      if (onToken) onToken(nextObj.word, stepInfo);
+      if (this._isTerminal(nextObj.word)) {
+        stopReason = "stop";
+        break;
+      }
+      if (tokens.length > promptLength + 2 && tokens.slice(-3).every((v) => v === tokens[tokens.length - 1])) {
+        stopReason = "stop";
+        break;
+      }
+    }
+    return {
+      prompt,
+      generatedText: tokens.join(" "),
+      newTokens: tokens.slice(promptLength),
+      steps,
+      totalLatencyMs: performance.now() - startTime,
+      finishReason: stopReason,
+      vocabSize: this.vocab.length
+    };
+  }
+  /**
+   * Analyze Turkish word morphology.
+   * @param {string} word - Turkish word to analyze
+   * @returns {Object} { word, root, suffixes, morphemes, harmony, syllables }
+   */
+  analyze(word) {
+    return this.morphology.analyze(word);
+  }
+  /**
+   * Get SDK runtime metrics.
+   * @returns {Object} { runtime, vocabSize, dimension, wasmActive, initialized }
+   */
+  getMetrics() {
+    return {
+      runtime: this._runtime,
+      vocabSize: this.vocab.length,
+      dimension: this.D,
+      wasmActive: this.wasmInstance !== null,
+      initialized: this._initialized
+    };
+  }
+  /**
+   * Instantiate an autonomous SovereignAgent.
+   * @returns {SovereignAgent}
+   */
+  createAgent() {
+    return new SovereignAgent(this);
+  }
+  // ── PRIVATE: WASM LOADER ───────────────────────────────────
+  async _loadWasm(options) {
+    const imports = { env: { cosf: Math.cos, sinf: Math.sin, atan2f: Math.atan2, expf: Math.exp, sqrtf: Math.sqrt } };
+    try {
+      if (options.wasmBinary) {
+        const mod = new WebAssembly.Module(options.wasmBinary);
+        this.wasmInstance = new WebAssembly.Instance(mod, imports);
+        this.wasmMemory = this.wasmInstance.exports.memory;
+      } else if (this._runtime === "browser") {
+        const url = options.wasmUrl || "../wasm/spectral_core.wasm";
+        const res = await fetch(url);
+        const buf = await res.arrayBuffer();
+        const mod = new WebAssembly.Module(buf);
+        this.wasmInstance = new WebAssembly.Instance(mod, imports);
+        this.wasmMemory = this.wasmInstance.exports.memory;
+      } else {
+        const fs2 = await import("fs");
+        const path = await import("path");
+        const { fileURLToPath } = await import("url");
+        const __dirname = path.dirname(fileURLToPath(import.meta.url));
+        const wasmPath = options.wasmPath || path.join(__dirname, "..", "wasm", "spectral_core.wasm");
+        if (fs2.existsSync(wasmPath)) {
+          const buf = fs2.readFileSync(wasmPath);
+          const mod = new WebAssembly.Module(buf);
+          this.wasmInstance = new WebAssembly.Instance(mod, imports);
+          this.wasmMemory = this.wasmInstance.exports.memory;
+        }
+      }
+    } catch (e) {
+      console.warn("ResonanceSDK: WASM load failed, Pure JS fallback active.", e.message);
+    }
+  }
+  // ── PRIVATE: VOCABULARY BUILDER ────────────────────────────
+  async _buildVocabulary(options) {
+    const corpus = [
+      // ── Orijinal genel corpus ──
+      "evimizden yeni \xE7\u0131kt\u0131k",
+      "yeni bir kitap ald\u0131m",
+      "bilimsel ara\u015Ft\u0131rmalar yapay zeka ile h\u0131zland\u0131",
+      "g\xFCzel bir g\xFCn ba\u015Flad\u0131",
+      "iyi bir insan olmak \xF6nemlidir",
+      "t\xFCrk\xE7e dil yap\u0131s\u0131 \xE7ok zengindir",
+      "yapay zeka insan beyni gibi \xE7al\u0131\u015F\u0131r",
+      "\xF6\u011Frenmek ve d\xFC\u015F\xFCnmek zihni geli\u015Ftirir",
+      "b\xFCy\xFCk bir ad\u0131m att\u0131k",
+      "yeni projeler \xFCzerinde \xE7al\u0131\u015F\u0131yoruz",
+      "okuma al\u0131\u015Fkanl\u0131\u011F\u0131 kazanmak \xF6nemlidir",
+      "bilim ve teknik d\xFCnyay\u0131 de\u011Fi\u015Ftiriyor",
+      "evimizden okula kadar y\xFCr\xFCd\xFCk",
+      "yapay zeka dil modelleri \xFCzerine kuruludur",
+      "yeni bir d\xFCnya bizi bekliyor",
+      "kitaplar en iyi arkada\u015Ft\u0131r",
+      "g\xFCzel bir gelecek in\u015Fa ediyoruz",
+      "iyi bir e\u011Fitim almak \xF6nemlidir",
+      "t\xFCrk\xE7e konu\u015Fmak ve yazmak \xE7ok g\xFCzel",
+      "bilimsel ger\xE7ekler her zaman kazan\u0131r",
+      "yapay sinir a\u011Flar\u0131 karma\u015F\u0131k modellerdir",
+      "beyin ve zihin ara\u015Ft\u0131rmalar\u0131 s\xFCr\xFCyor",
+      "evimizden yeni bir yola \xE7\u0131kt\u0131k",
+      "yeni bir ba\u015Flang\u0131\xE7 yapmak iyidir",
+      "bilimsel okuma yapmak zihni a\xE7ar",
+      "okuma yapmak insan\u0131 geli\u015Ftirir",
+      "evimizden \xE7\u0131kt\u0131k ve okula gittik",
+      "yeni bir g\xFCne uyand\u0131k",
+      "bilim insanlar\u0131 yapay zeka geli\u015Ftiriyor",
+      "t\xFCrk\xE7e dil bilgisi kurallar\u0131 \xF6nemlidir",
+      "evimizden okula gittik yeni bir kitap ald\u0131k",
+      "televizyonu a\xE7\u0131p haberleri izledik",
+      "arabaya binip okula gittik",
+      "bilgisayar\u0131 kapat\u0131p uyudum",
+      "bilgisayar\u0131 kapat\u0131p yatt\u0131m",
+      "yaz\u0131l\u0131m m\xFChendisleri yapay zeka modelleri \xFCzerine ara\u015Ft\u0131rma yap\u0131yor",
+      "bilgi teknolojileri ve veri analizi i\u015F s\xFCre\xE7lerini kolayla\u015Ft\u0131r\u0131r",
+      "sa\u011Fl\u0131kl\u0131 beslenme ve spor yapmak ya\u015Fam kalitesini art\u0131r\u0131r",
+      "do\u011Fal ya\u015Fam\u0131 ve \xE7evreyi korumak hepimizin sorumlulu\u011Fundad\u0131r",
+      "sanat ve edebiyat toplumun k\xFClt\xFCrel zenginli\u011Fini besler ve geli\u015Ftirir",
+      "e\u011Fitim sistemi yeni nesillerin gelece\u011Fini ve ba\u015Far\u0131s\u0131n\u0131 belirler",
+      "bilgisayar a\u011Flar\u0131 veri g\xFCvenli\u011Fi ve h\u0131zl\u0131 bilgi ak\u0131\u015F\u0131 sa\u011Flar",
+      // ── Selamlama ve bağlam kurma ──
+      "merhaba size nas\u0131l yard\u0131mc\u0131 olabilirim",
+      "g\xFCnayd\u0131n bug\xFCn size nas\u0131l yard\u0131mc\u0131 olay\u0131m",
+      "iyi g\xFCnler l\xFCtfen sorunuzu belirtin",
+      "ho\u015F geldiniz nas\u0131l yard\u0131mc\u0131 olabilirim",
+      "merhaba buyurun nas\u0131l yard\u0131mc\u0131 olay\u0131m",
+      "iyi ak\u015Famlar size nas\u0131l yard\u0131mc\u0131 olabilirim",
+      // ── Hasta kaydı kalıpları ──
+      "hasta kayd\u0131 olu\u015Fturuldu",
+      "kay\u0131t sisteme ba\u015Far\u0131yla eklendi",
+      "hastan\u0131n bilgileri g\xFCncellendi",
+      "bu hasta daha \xF6nce kay\u0131t edilmemi\u015F",
+      "hastan\u0131n ad\u0131 ve ya\u015F\u0131 kaydedildi",
+      "hasta bilgileri sisteme girildi",
+      "yeni hasta kayd\u0131 a\xE7\u0131ld\u0131",
+      "hasta \u015Fikayeti sisteme i\u015Flendi",
+      "kay\u0131t ba\u015Far\u0131yla g\xFCncellendi",
+      "hastan\u0131n ge\xE7mi\u015F kay\u0131tlar\u0131 bulundu",
+      "bu hasta i\xE7in kay\u0131t bulunamad\u0131",
+      "hastan\u0131n durumu kaydedildi",
+      // ── Belirsizlik ve yönlendirme ──
+      "bu soruyu yan\u0131tlayacak bilgiye sahip de\u011Filim",
+      "bu konuda bilgim yok ba\u015Fka bir soru sorabilirsiniz",
+      "l\xFCtfen daha fazla bilgi verir misiniz",
+      "hangi hastay\u0131 soruyorsunuz",
+      "bu bilgi haf\u0131zada bulunamad\u0131",
+      "hen\xFCz bu konuda kay\u0131t yok",
+      "bu i\u015Flemi yapabilmem i\xE7in daha fazla bilgiye ihtiyac\u0131m var",
+      "maalesef bu konuda yard\u0131mc\u0131 olam\u0131yorum",
+      // ── Sağlık domain kalıpları ──
+      "hastan\u0131n \u015Fikayeti ba\u015F a\u011Fr\u0131s\u0131 ve tansiyon y\xFCksekli\u011Fi",
+      "kan bas\u0131nc\u0131 de\u011Feri y\xFCz k\u0131rk b\xF6l\xFC doksan olarak \xF6l\xE7\xFCld\xFC",
+      "ila\xE7 dozu hesapland\u0131 ve re\xE7eteye yaz\u0131ld\u0131",
+      "risk durumu y\xFCksek riskli olarak i\u015Faretlendi",
+      "hastan\u0131n kan \u015Fekeri y\xFCz seksen olarak \xF6l\xE7\xFCld\xFC",
+      "diyabet hastas\u0131 olarak kay\u0131t edildi",
+      "gebelik takibi i\xE7in kontrol randevusu olu\u015Fturuldu",
+      "hastan\u0131n ate\u015Fi otuz sekiz derece \xF6l\xE7\xFCld\xFC",
+      "tansiyon \xF6l\xE7\xFCm\xFC yap\u0131ld\u0131 ve kaydedildi",
+      "ila\xE7lardan hangisinin verilmesi gerekti\u011Fi belirlendi",
+      "doktorlar\u0131m\u0131zdan birini \xE7a\u011F\u0131rabilir misiniz",
+      "hastan\u0131n ayaklar\u0131ndan birinde \u015Fi\u015Flik tespit edildi",
+      "kan grubu belirlenmesi i\xE7in tahlil istendi",
+      "hastaya g\xFCnde \xFC\xE7 kez ila\xE7 verilecek",
+      "haftal\u0131k toplam doz hesapland\u0131",
+      "ameliyat \xF6ncesi haz\u0131rl\u0131klar tamamland\u0131",
+      "hastan\u0131n nabz\u0131 ve tansiyonu normal s\u0131n\u0131rlarda",
+      "tedavi plan\u0131 olu\u015Fturuldu ve hastaya bildirildi",
+      "a\u015F\u0131 takvimi kontrol edildi",
+      "acil m\xFCdahale gerekli de\u011Fil hasta stabil",
+      // ── Çelişki ve doğrulama ──
+      "kay\u0131tlarda \xE7eli\u015Fen bilgi tespit edildi",
+      "l\xFCtfen do\u011Fru bilgiyi belirtin",
+      "iki farkl\u0131 kay\u0131t bulundu hangisi do\u011Fru",
+      "bu bilgi \xF6nceki kay\u0131tla \xE7eli\u015Fiyor",
+      "\xE7eli\u015Fen kay\u0131tlar kullan\u0131c\u0131ya sunuldu",
+      // ── Morfoloji zenginleştirme ──
+      "evlerimizden geliyoruz hasta getirdik",
+      "hastan\u0131n ayaklar\u0131ndan birinde \u015Fi\u015Flik var",
+      "ila\xE7lardan hangisini vermemiz gerekiyor",
+      "doktorlar\u0131m\u0131zdan birini \xE7a\u011F\u0131rabilir misiniz",
+      "bu hastal\u0131klardan kurtulabilir mi",
+      "k\xF6ylerden gelen hastalar muayene edildi",
+      "\xE7ocuklar\u0131n a\u015F\u0131lar\u0131 yap\u0131ld\u0131",
+      "hastalar\u0131n kay\u0131tlar\u0131 g\xFCncellendi"
+    ];
+    let initialVocab = [];
+    try {
+      if (this._runtime === "browser") {
+        const url = options.corpusUrl || "../tr_corpus_embed.js";
+        const res = await fetch(url);
+        const txt = await res.text();
+        const m = txt.match(/const TR_CORPUS_ROOTS\s*=\s*(\[[\s\S]*?\]);/);
+        if (m) initialVocab = JSON.parse(m[1]);
+      } else {
+        const fs2 = await import("fs");
+        const path = await import("path");
+        const { fileURLToPath } = await import("url");
+        const __dirname = path.dirname(fileURLToPath(import.meta.url));
+        const corpusPath = options.corpusPath || path.join(__dirname, "..", "tr_corpus_embed.js");
+        if (fs2.existsSync(corpusPath)) {
+          const txt = fs2.readFileSync(corpusPath, "utf8");
+          const m = txt.match(/const TR_CORPUS_ROOTS\s*=\s*(\[[\s\S]*?\]);/);
+          if (m) initialVocab = JSON.parse(m[1]);
+        }
+      }
+    } catch (e) {
+    }
+    const turkishRe = /^[a-zçgğıoöşuüâîû]+$/;
+    const words = /* @__PURE__ */ new Set([
+      "ev",
+      "yeni",
+      "bir",
+      "kitap",
+      "okul",
+      "\xE7\u0131kt\u0131k",
+      "ald\u0131m",
+      "g\xFCzel",
+      "iyi",
+      "yapay",
+      "zeka",
+      "bilimsel",
+      "okuma",
+      "\xF6\u011Frenmek",
+      "dil",
+      "t\xFCrk\xE7e",
+      "insan",
+      "olmak",
+      "\xF6nemlidir",
+      "geli\u015Ftirir",
+      "de\u011Fi\u015Ftiriyor",
+      "y\xFCr\xFCd\xFCk",
+      "gittik",
+      "yola",
+      "ba\u015Flang\u0131\xE7",
+      "g\xFCne",
+      "uyand\u0131k",
+      "kuruludur",
+      "televizyonu",
+      "a\xE7\u0131p",
+      "izledik",
+      "izledim",
+      "arabaya",
+      "binip",
+      "bilgisayar\u0131",
+      "kapat\u0131p",
+      "uyudum",
+      "yatt\u0131m"
+    ]);
+    this.wordCounts.clear();
+    for (const s of corpus) {
+      for (const w of s.split(/\s+/)) {
+        const c = w.trim().toLowerCase().replace(/[^a-zçgğıoöşuüâîû]/g, "");
+        if (c.length >= 2 && turkishRe.test(c)) {
+          this.wordCounts.set(c, (this.wordCounts.get(c) || 0) + 1);
+        }
+      }
+    }
+    for (const [w, cnt] of this.wordCounts) {
+      if (cnt >= 2) words.add(w);
+    }
+    for (const w of initialVocab) {
+      const c = w.trim().toLowerCase().replace(/[^a-zçgğıoöşuüâîû]/g, "");
+      if (c.length >= 2 && turkishRe.test(c)) {
+        for (const d of generateDerivations(c, this.morphology)) words.add(d);
+      }
+    }
+    this.vocab = ["<unk>", ...Array.from(words)];
+    this.vocabMap.clear();
+    for (let i = 0; i < this.vocab.length; i++) this.vocabMap.set(this.vocab[i], i);
+    this.freqIndices = this.vocab.map((w, idx) => ({ w, idx })).sort((a, b) => (this.wordCounts.get(b.w) || 0) - (this.wordCounts.get(a.w) || 0)).slice(0, 15).map((x) => x.idx);
+    this.wordDerivationIndices.clear();
+    for (const root of this.vocab) {
+      const indices = [];
+      for (const d of generateDerivations(root, this.morphology)) {
+        const idx = this.vocabMap.get(d);
+        if (idx !== void 0) indices.push(idx);
+      }
+      this.wordDerivationIndices.set(root, indices);
+    }
+    for (const word of this.vocab) {
+      const emb = this.hdc.generateSeeded("complex", word);
+      emb.values = new Float32Array(emb.values);
+      const cos = new Float32Array(this.D);
+      const sin = new Float32Array(this.D);
+      for (let i = 0; i < this.D; i++) {
+        cos[i] = Math.cos(emb.values[i]);
+        sin[i] = Math.sin(emb.values[i]);
+      }
+      this.embeddings.set(word, { emb, cosVals: cos, sinVals: sin });
+    }
+    if (this.wasmInstance) {
+      const V = this.vocab.length, DD = this.D;
+      this.vocabCosPtr = this.wasmInstance.exports.malloc(V * DD * 4);
+      this.vocabSinPtr = this.wasmInstance.exports.malloc(V * DD * 4);
+      this.scoresPtr = this.wasmInstance.exports.malloc(V * 4);
+      this.transIndicesPtr = this.wasmInstance.exports.malloc(64 * 4);
+      this.transMultipliersPtr = this.wasmInstance.exports.malloc(64 * 4);
+      this.topIndicesPtr = this.wasmInstance.exports.malloc(5 * 4);
+      this.topScoresPtr = this.wasmInstance.exports.malloc(5 * 4);
+      this.candidateIndicesPtr = this.wasmInstance.exports.malloc(1024 * 4);
+      if (this.vocabCosPtr && this.vocabSinPtr && this.scoresPtr && this.transIndicesPtr && this.transMultipliersPtr && this.topIndicesPtr && this.topScoresPtr && this.candidateIndicesPtr) {
+        const mem = this.wasmMemory.buffer;
+        const cosView = new Float32Array(mem, this.vocabCosPtr, V * DD);
+        const sinView = new Float32Array(mem, this.vocabSinPtr, V * DD);
+        for (let v = 0; v < V; v++) {
+          const data = this.embeddings.get(this.vocab[v]);
+          cosView.set(data.cosVals, v * DD);
+          sinView.set(data.sinVals, v * DD);
+        }
+      } else {
+        console.warn("ResonanceSDK: WASM malloc failed, falling back to Pure JS.");
+        this.wasmInstance = null;
+      }
+    }
+    this.transitionCounts = /* @__PURE__ */ new Map();
+    const re = new Float32Array(this.D), im = new Float32Array(this.D);
+    let tCount = 0;
+    for (const s of corpus) {
+      const ws = s.split(/\s+/).map((w) => w.trim().toLowerCase().replace(/[^a-zçgğıoöşuüâîû]/g, "")).filter((w) => w.length >= 2);
+      for (let i = 0; i < ws.length - 1; i++) {
+        const w1 = ws[i], w2 = ws[i + 1];
+        if (!this.transitionCounts.has(w1)) this.transitionCounts.set(w1, /* @__PURE__ */ new Map());
+        this.transitionCounts.get(w1).set(w2, (this.transitionCounts.get(w1).get(w2) || 0) + 1);
+        const d1 = this.embeddings.get(w1), d2 = this.embeddings.get(w2);
+        if (d1 && d2) {
+          const wt = 1 / Math.sqrt(this.wordCounts.get(w2) || 1);
+          for (let j = 0; j < this.D; j++) {
+            let diff = d2.emb.values[j] - d1.emb.values[j];
+            if (diff < 0) diff += 2 * Math.PI;
+            re[j] += wt * Math.cos(diff % (2 * Math.PI));
+            im[j] += wt * Math.sin(diff % (2 * Math.PI));
+          }
+          tCount++;
+        }
+      }
+    }
+    if (tCount > 0) {
+      const vals = new Float32Array(this.D);
+      for (let j = 0; j < this.D; j++) {
+        let v = Math.atan2(im[j], re[j]);
+        if (v < 0) v += 2 * Math.PI;
+        vals[j] = v;
+      }
+      this.sparseWeightsSpec = new Representation("complex", vals, this.D);
+    } else {
+      this.sparseWeightsSpec = this.hdc.generateSeeded("complex", "fallback_transitions");
+    }
+    if (this.wasmInstance && this.sparseWeightsSpec) {
+      const mem = this.wasmMemory.buffer;
+      const trRe = new Float32Array(mem, this.wasmInstance.exports.get_transition_spec_re_ptr(), this.D);
+      const trIm = new Float32Array(mem, this.wasmInstance.exports.get_transition_spec_im_ptr(), this.D);
+      for (let j = 0; j < this.D; j++) {
+        trRe[j] = Math.cos(this.sparseWeightsSpec.values[j]);
+        trIm[j] = Math.sin(this.sparseWeightsSpec.values[j]);
+      }
+    }
+  }
+  _predictNext(tokens, temperature, promptLength) {
+    if (this.wasmInstance && this.wasmMemory) {
+      return this._predictWasm(tokens, temperature, promptLength);
+    }
+    return this._predictJS(tokens, temperature, promptLength);
+  }
+  _predictWasm(tokens, temperature, promptLength) {
+    const mem = this.wasmMemory.buffer;
+    const ctxPtr = this.wasmInstance.exports.get_context_angles_ptr();
+    const ctxView = new Float32Array(mem, ctxPtr, this.D);
+    if (promptLength > 0 && tokens.length > promptLength) {
+      let pIdx = this.vocabMap.get(tokens[promptLength - 1]) ?? 0;
+      let gIdx = this.vocabMap.get(tokens[tokens.length - 1]) ?? 0;
+      this.wasmInstance.exports.combine_phases_by_indices(
+        pIdx,
+        0.4,
+        gIdx,
+        0.6,
+        this.vocabCosPtr,
+        this.vocabSinPtr,
+        ctxPtr
+      );
+    } else {
+      const lastData = this.embeddings.get(tokens[tokens.length - 1]) || this.embeddings.get("<unk>");
+      ctxView.set(lastData.emb.values);
+    }
+    this.wasmInstance.exports.spectral_predict();
+    const candView = new Int32Array(mem, this.candidateIndicesPtr, 1024);
+    const freqLen = this.freqIndices.length;
+    for (let i = 0; i < freqLen; i++) {
+      candView[i] = this.freqIndices[i];
+    }
+    let numCandidates = freqLen;
+    for (let i = 0; i < promptLength; i++) {
+      const idx = this.vocabMap.get(tokens[i]);
+      if (idx !== void 0 && numCandidates < 1024) {
+        candView[numCandidates++] = idx;
+      }
+    }
+    const lastToken = tokens[tokens.length - 1];
+    let numTransitions = -1;
+    if (lastToken) {
+      const m = this.transitionCounts.get(lastToken);
+      if (!m) {
+        numTransitions = 0;
+      } else {
+        const transIndices = new Int32Array(mem, this.transIndicesPtr, m.size);
+        const transMultipliers = new Float32Array(mem, this.transMultipliersPtr, m.size);
+        let idx = 0;
+        for (const [nextWord, count] of m.entries()) {
+          const wordIdx = this.vocabMap.get(nextWord);
+          if (wordIdx !== void 0) {
+            transIndices[idx] = wordIdx;
+            transMultipliers[idx] = 1.5 + count * 2;
+            idx++;
+            if (numCandidates < 1024) {
+              candView[numCandidates++] = wordIdx;
+            }
+            const derivationsIndices = this.wordDerivationIndices.get(nextWord);
+            if (derivationsIndices) {
+              const derivLen = derivationsIndices.length;
+              for (let d = 0; d < derivLen; d++) {
+                if (numCandidates < 1024) {
+                  candView[numCandidates++] = derivationsIndices[d];
+                }
+              }
+            }
+          }
+        }
+        numTransitions = idx;
+      }
+    }
+    this.wasmInstance.exports.compute_similarity_for_candidates(
+      this.candidateIndicesPtr,
+      numCandidates,
+      this.vocabCosPtr,
+      this.vocabSinPtr,
+      this.transIndicesPtr,
+      this.transMultipliersPtr,
+      numTransitions,
+      this.topIndicesPtr,
+      this.topScoresPtr
+    );
+    const topIndicesView = new Int32Array(mem, this.topIndicesPtr, 5);
+    const topScoresView = new Float32Array(mem, this.topScoresPtr, 5);
+    const candidates = [];
+    const lastHarmony = lastToken ? this.morphology.determineVowelHarmony(lastToken) : null;
+    const recentK = tokens.slice(-4);
+    for (let i = 0; i < 5; i++) {
+      const wordIdx = topIndicesView[i];
+      if (wordIdx === -1) continue;
+      const word = this.vocab[wordIdx];
+      let score = topScoresView[i];
+      if (tokens.length >= 1) {
+        const last1 = tokens[tokens.length - 1];
+        for (let idx = 0; idx < tokens.length - 1; idx++) {
+          if (tokens[idx] === last1 && tokens[idx + 1] === word) {
+            score = 0;
+            break;
+          }
+        }
+      }
+      if (tokens.length >= 2) {
+        const last2 = tokens[tokens.length - 2];
+        const last1 = tokens[tokens.length - 1];
+        for (let idx = 0; idx < tokens.length - 2; idx++) {
+          if (tokens[idx] === last2 && tokens[idx + 1] === last1 && tokens[idx + 2] === word) {
+            score = 0;
+            break;
+          }
+        }
+      }
+      if (recentK.includes(word)) {
+        score *= 0.1;
+      }
+      if (lastHarmony && this.morphology.suffixFeatures.hasOwnProperty(word)) {
+        const suffixHarmony = this.morphology.determineVowelHarmony(word);
+        if (suffixHarmony !== lastHarmony) score = 0;
+      } else if (lastHarmony) {
+        const candidateHarmony = this.morphology.determineVowelHarmony(word);
+        if (candidateHarmony === lastHarmony) score *= 1.15;
+      }
+      candidates.push({ word, score });
+    }
+    candidates.sort((a, b) => b.score - a.score);
+    return this._sample(candidates, temperature);
+  }
+  _predictJS(tokens, temperature, promptLength) {
+    const ctx = new Float32Array(this.D);
+    if (promptLength > 0 && tokens.length > promptLength) {
+      const pD = this.embeddings.get(tokens[promptLength - 1]) || this.embeddings.get("<unk>");
+      const gD = this.embeddings.get(tokens[tokens.length - 1]) || this.embeddings.get("<unk>");
+      for (let j = 0; j < this.D; j++) {
+        let v = pD.emb.values[j] + gD.emb.values[j];
+        if (v < 0) v += 2 * Math.PI;
+        ctx[j] = v % (2 * Math.PI);
+      }
+    } else {
+      const ld = this.embeddings.get(tokens[tokens.length - 1]) || this.embeddings.get("<unk>");
+      ctx.set(ld.emb.values);
+    }
+    const query = new Float32Array(this.D);
+    for (let j = 0; j < this.D; j++) {
+      let v = ctx[j] + (this.sparseWeightsSpec ? this.sparseWeightsSpec.values[j] : 0);
+      if (v < 0) v += 2 * Math.PI;
+      query[j] = v % (2 * Math.PI);
+    }
+    const cosY = new Float32Array(this.D);
+    const sinY = new Float32Array(this.D);
+    for (let i = 0; i < this.D; i++) {
+      cosY[i] = Math.cos(query[i]);
+      sinY[i] = Math.sin(query[i]);
+    }
+    const candidates = [];
+    const lastToken = tokens[tokens.length - 1];
+    const lastHarmony = lastToken ? this.morphology.determineVowelHarmony(lastToken) : null;
+    const recentK = tokens.slice(-4);
+    for (const [word, data] of this.embeddings.entries()) {
+      let sumCos = 0;
+      const cosEmb = data.cosVals;
+      const sinEmb = data.sinVals;
+      for (let i = 0; i < this.D; i++) {
+        sumCos += cosY[i] * cosEmb[i] + sinY[i] * sinEmb[i];
+      }
+      let score = sumCos / this.D;
+      score = Math.max(1e-4, (score + 1) / 2);
+      if (lastToken) {
+        const m = this.transitionCounts.get(lastToken);
+        if (m) {
+          const count = m.get(word) || 0;
+          score *= count > 0 ? 1.5 + count * 2 : 0.1;
+        } else {
+          score *= 0.5;
+        }
+      }
+      if (tokens.length >= 1) {
+        const last1 = tokens[tokens.length - 1];
+        for (let i = 0; i < tokens.length - 1; i++) {
+          if (tokens[i] === last1 && tokens[i + 1] === word) {
+            score = 0;
+            break;
+          }
+        }
+      }
+      if (tokens.length >= 2) {
+        const last2 = tokens[tokens.length - 2];
+        const last1 = tokens[tokens.length - 1];
+        for (let i = 0; i < tokens.length - 2; i++) {
+          if (tokens[i] === last2 && tokens[i + 1] === last1 && tokens[i + 2] === word) {
+            score = 0;
+            break;
+          }
+        }
+      }
+      if (recentK.includes(word)) {
+        score *= 0.1;
+      }
+      if (lastHarmony && this.morphology.suffixFeatures.hasOwnProperty(word)) {
+        const suffixHarmony = this.morphology.determineVowelHarmony(word);
+        if (suffixHarmony !== lastHarmony) score = 0;
+      } else if (lastHarmony) {
+        const candidateHarmony = this.morphology.determineVowelHarmony(word);
+        if (candidateHarmony === lastHarmony) score *= 1.15;
+      }
+      candidates.push({ word, score });
+    }
+    candidates.sort((a, b) => b.score - a.score);
+    return this._sample(candidates.slice(0, 5), temperature);
+  }
+  _sample(candidates, temperature) {
+    if (!candidates.length) return { word: "<unk>", score: 0 };
+    if (temperature <= 0.05) return candidates[0];
+    const max = candidates[0].score;
+    const exp = candidates.map((c) => Math.exp((c.score - max) / temperature));
+    const sum = exp.reduce((a, v) => a + v, 0);
+    const probs = exp.map((v) => v / sum);
+    const r = Math.random();
+    let cum = 0;
+    for (let i = 0; i < candidates.length; i++) {
+      cum += probs[i];
+      if (r <= cum) return candidates[i];
+    }
+    return candidates[0];
+  }
+  _isTerminal(word) {
+    const terminals = /* @__PURE__ */ new Set([
+      ".",
+      "gittik",
+      "ald\u0131m",
+      "ald\u0131k",
+      "geli\u015Ftirir",
+      "uyand\u0131k",
+      "kuruludur",
+      "\xE7\u0131kt\u0131k",
+      "izledim",
+      "izledik",
+      "uyudum",
+      "yatt\u0131m",
+      "gittim",
+      "yapt\u0131m",
+      "\xF6\u011Frendim"
+    ]);
+    return terminals.has(word) || word.endsWith(".");
+  }
+  _assertInit() {
+    if (!this._initialized) throw new Error("ResonanceSDK: Not initialized. Call await sdk.init() first.");
+  }
+};
+export {
+  ResonanceSDK
+};
+/**
+ * Resonance SDK v1.0 - B2B Commercial Edge AI Engine
+ * Unified SDK interface wrapping the Turkish Resonance AI Core (v5.2).
+ * Supports both Browser (fetch/streaming) and Node.js environments.
+ * 
+ * @license Commercial - Per-device licensing
+ * @author Turkish Resonance AI Core Team
+ */