tdk-api-wrapper 1.2.0 → 1.2.1

package/README.md

@@ -68,7 +68,7 @@ Aşağıdaki metotlar `TDK` sınıfı üzerinden statik olarak erişilebilir dur
 - **`TDK.syllabicate(word)`**: Kelimeyi Türkçe heceleme kurallarına göre doğru hecelerine ayırır (Örn: `['mu', 'vaf', 'fa', 'ki', 'yet']`). API isteği atmaz, çok hızlıdır.
 - **`TDK.checkVowelHarmony(word)`**: Kelimenin büyük ünlü uyumuna uyup uymadığını (boolean) kontrol eder.
 - **`TDK.getPartOfSpeech(word)`**: Kelimenin sözcük türünü (isim, sıfat, zarf vb.) döndürür.
-- **`TDK.checkSpelling(word)`**: Sıkça yapılan yanlışlar listesini ve TDK veritabanını kullanarak kelimenin doğru yazılıp yazılmadığını kontrol eder. Yanlışsa doğrusunu önerir; tam eşleşme yoksa, aynı listedeki kelimeler arasında edit-distance (Levenshtein) ile en yakınını önerir (not: tüm sözlükte değil, yalnızca bu küçük havuzda arama yapar).
+- **`TDK.checkSpelling(word)`**: Kelimenin doğru yazılıp yazılmadığını kontrol eder. Önce TDK'nin "sık yapılan yanlışlar" listesinde tam eşleşme arar; bulamazsa TDK'nin ~81 bin kelimelik tam madde listesi üzerinde edit-distance (Levenshtein) ile en yakın kelimeyi önerir (örn. `herkez` → `herkes`, `mektub` → `mektup`).
 - **`TDK.getCompoundWords(word)`**: Aranan kelime ile oluşturulmuş birleşik kelimeleri (Örn: dolma kalem) listeler.
 
 ### 3. Edebi ve Kültürel Analiz

package/dist/{chunk-2TA5PMVZ.mjs → chunk-6BTOGV2M.mjs}

@@ -390,29 +390,37 @@ var TDK = class {
       if (mixMatch) {
         return { isCorrect: false, word, suggestion: mixMatch.dogru };
       }
-      const candidates = [
-        ...daily.syyd.map((s) => s.dogrukelime),
-        ...daily.karistirma.flatMap((s) => [s.yanlis, s.dogru]),
-        ...daily.kelime.map((k) => k.madde)
-      ];
-      let best = null;
-      for (const candidate of candidates) {
-        const distance = this.levenshtein(word.toLocaleLowerCase("tr-TR"), candidate.toLocaleLowerCase("tr-TR"));
-        if (distance > 0 && (!best || distance < best.distance)) {
-          best = { candidate, distance };
-        }
-      }
-      if (best && best.distance <= 2) {
-        return { isCorrect: false, word, suggestion: best.candidate };
+    }
+    if (this.autocompleteCache.length === 0) {
+      this.autocompleteCache = await this.fetchAutocompleteData();
+    }
+    const cleanWord = word.trim().toLocaleLowerCase("tr-TR");
+    let best = null;
+    for (const candidate of this.autocompleteCache) {
+      if (candidate.includes(" ") || candidate !== candidate.toLocaleLowerCase("tr-TR"))
+        continue;
+      const distance = this.levenshtein(cleanWord, candidate);
+      if (distance > 0 && (!best || distance < best.distance)) {
+        best = { candidate, distance };
+        if (distance === 1)
+          break;
       }
     }
+    if (best && best.distance <= 2) {
+      return { isCorrect: false, word, suggestion: best.candidate };
+    }
     return { isCorrect: false, word };
   }
   /**
    * Fetches daily content (word of the day, proverbs, rules, etc).
+   * `bypassCache` skips both reading and writing `dailyContentCache` even
+   * when `enableCache(true)` is on — used by `getRule()`'s retry loop, which
+   * needs a fresh random `/icerik` draw on every attempt; without it, once
+   * caching is enabled the loop would just re-read the same cached response
+   * 25 times and could never find a rule outside that first random draw.
    */
-  static async getDailyContent() {
-    if (this.isCacheEnabled && this.dailyContentCache)
+  static async getDailyContent(bypassCache = false) {
+    if (!bypassCache && this.isCacheEnabled && this.dailyContentCache)
       return this.dailyContentCache;
     try {
       const response = await fetch(`${this.BASE_URL}/icerik`, {
@@ -420,7 +428,7 @@ var TDK = class {
       });
       if (response.ok) {
         const data = await response.json();
-        if (this.isCacheEnabled)
+        if (!bypassCache && this.isCacheEnabled)
           this.dailyContentCache = data;
         return data;
       }
@@ -461,10 +469,12 @@ var TDK = class {
    * `/icerik` daily-content feed, e.g. `{ adi: "Kısaltmalar", url: "https://..." }`.
    * Note: like `getRandomWord()`, this is NOT a fixed catalog — `/icerik`
    * appears to hand back a single randomly-rotated rule per request, so two
-   * calls a second apart can return entirely different rules.
+   * calls a second apart can return entirely different rules. `bypassCache`
+   * (used internally by `getRule()`'s retry loop) forces a fresh `/icerik`
+   * draw even when `enableCache(true)` is on.
    */
-  static async getKurallar() {
-    const daily = await this.getDailyContent();
+  static async getKurallar(bypassCache = false) {
+    const daily = await this.getDailyContent(bypassCache);
     return daily?.kural ?? [];
   }
   /**
@@ -473,16 +483,19 @@ var TDK = class {
    * hands back a single randomly-rotated rule per request (out of a pool of
    * roughly twenty) rather than a fixed catalog, a single `getKurallar()`
    * draw would rarely match a given name — this re-draws (bounded, with a
-   * short delay) until it finds a match or gives up. Returns `null` if no
-   * match turns up within the attempt budget or the matched page can't be
-   * parsed.
+   * short delay) until it finds a match or gives up. Every attempt bypasses
+   * `dailyContentCache` — without that, once `enableCache(true)` is on, all
+   * 25 attempts would just re-read the same cached `/icerik` response and
+   * could never find a rule outside whatever the first draw happened to be.
+   * Returns `null` if no match turns up within the attempt budget or the
+   * matched page can't be parsed.
    */
   static async getRule(name) {
     if (!name || name.trim() === "")
       return null;
     const target = name.trim().toLocaleLowerCase("tr-TR");
     for (let attempt = 0; attempt < 25; attempt++) {
-      const rules = await this.getKurallar();
+      const rules = await this.getKurallar(true);
       const match = rules.find((r) => r.adi.toLocaleLowerCase("tr-TR").includes(target));
       if (match)
         return this.fetchRuleText(match.url);

package/dist/cli.js

@@ -415,29 +415,37 @@ var TDK = class {
       if (mixMatch) {
         return { isCorrect: false, word: word2, suggestion: mixMatch.dogru };
       }
-      const candidates = [
-        ...daily.syyd.map((s) => s.dogrukelime),
-        ...daily.karistirma.flatMap((s) => [s.yanlis, s.dogru]),
-        ...daily.kelime.map((k) => k.madde)
-      ];
-      let best = null;
-      for (const candidate of candidates) {
-        const distance = this.levenshtein(word2.toLocaleLowerCase("tr-TR"), candidate.toLocaleLowerCase("tr-TR"));
-        if (distance > 0 && (!best || distance < best.distance)) {
-          best = { candidate, distance };
-        }
-      }
-      if (best && best.distance <= 2) {
-        return { isCorrect: false, word: word2, suggestion: best.candidate };
+    }
+    if (this.autocompleteCache.length === 0) {
+      this.autocompleteCache = await this.fetchAutocompleteData();
+    }
+    const cleanWord = word2.trim().toLocaleLowerCase("tr-TR");
+    let best = null;
+    for (const candidate of this.autocompleteCache) {
+      if (candidate.includes(" ") || candidate !== candidate.toLocaleLowerCase("tr-TR"))
+        continue;
+      const distance = this.levenshtein(cleanWord, candidate);
+      if (distance > 0 && (!best || distance < best.distance)) {
+        best = { candidate, distance };
+        if (distance === 1)
+          break;
       }
     }
+    if (best && best.distance <= 2) {
+      return { isCorrect: false, word: word2, suggestion: best.candidate };
+    }
     return { isCorrect: false, word: word2 };
   }
   /**
    * Fetches daily content (word of the day, proverbs, rules, etc).
+   * `bypassCache` skips both reading and writing `dailyContentCache` even
+   * when `enableCache(true)` is on — used by `getRule()`'s retry loop, which
+   * needs a fresh random `/icerik` draw on every attempt; without it, once
+   * caching is enabled the loop would just re-read the same cached response
+   * 25 times and could never find a rule outside that first random draw.
    */
-  static async getDailyContent() {
-    if (this.isCacheEnabled && this.dailyContentCache)
+  static async getDailyContent(bypassCache = false) {
+    if (!bypassCache && this.isCacheEnabled && this.dailyContentCache)
       return this.dailyContentCache;
     try {
       const response = await fetch(`${this.BASE_URL}/icerik`, {
@@ -445,7 +453,7 @@ var TDK = class {
       });
       if (response.ok) {
         const data = await response.json();
-        if (this.isCacheEnabled)
+        if (!bypassCache && this.isCacheEnabled)
           this.dailyContentCache = data;
         return data;
       }
@@ -486,10 +494,12 @@ var TDK = class {
    * `/icerik` daily-content feed, e.g. `{ adi: "Kısaltmalar", url: "https://..." }`.
    * Note: like `getRandomWord()`, this is NOT a fixed catalog — `/icerik`
    * appears to hand back a single randomly-rotated rule per request, so two
-   * calls a second apart can return entirely different rules.
+   * calls a second apart can return entirely different rules. `bypassCache`
+   * (used internally by `getRule()`'s retry loop) forces a fresh `/icerik`
+   * draw even when `enableCache(true)` is on.
    */
-  static async getKurallar() {
-    const daily = await this.getDailyContent();
+  static async getKurallar(bypassCache = false) {
+    const daily = await this.getDailyContent(bypassCache);
     return daily?.kural ?? [];
   }
   /**
@@ -498,16 +508,19 @@ var TDK = class {
    * hands back a single randomly-rotated rule per request (out of a pool of
    * roughly twenty) rather than a fixed catalog, a single `getKurallar()`
    * draw would rarely match a given name — this re-draws (bounded, with a
-   * short delay) until it finds a match or gives up. Returns `null` if no
-   * match turns up within the attempt budget or the matched page can't be
-   * parsed.
+   * short delay) until it finds a match or gives up. Every attempt bypasses
+   * `dailyContentCache` — without that, once `enableCache(true)` is on, all
+   * 25 attempts would just re-read the same cached `/icerik` response and
+   * could never find a rule outside whatever the first draw happened to be.
+   * Returns `null` if no match turns up within the attempt budget or the
+   * matched page can't be parsed.
    */
   static async getRule(name) {
     if (!name || name.trim() === "")
       return null;
     const target = name.trim().toLocaleLowerCase("tr-TR");
     for (let attempt = 0; attempt < 25; attempt++) {
-      const rules = await this.getKurallar();
+      const rules = await this.getKurallar(true);
       const match = rules.find((r) => r.adi.toLocaleLowerCase("tr-TR").includes(target));
       if (match)
         return this.fetchRuleText(match.url);

package/dist/cli.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   TDK
-} from "./chunk-2TA5PMVZ.mjs";
+} from "./chunk-6BTOGV2M.mjs";
 
 // src/cli.ts
 var rawArgs = process.argv.slice(2);

package/dist/index.d.mts

@@ -244,8 +244,13 @@ declare class TDK {
     static checkSpelling(word: string): Promise<SpellCheckResult>;
     /**
      * Fetches daily content (word of the day, proverbs, rules, etc).
+     * `bypassCache` skips both reading and writing `dailyContentCache` even
+     * when `enableCache(true)` is on — used by `getRule()`'s retry loop, which
+     * needs a fresh random `/icerik` draw on every attempt; without it, once
+     * caching is enabled the loop would just re-read the same cached response
+     * 25 times and could never find a rule outside that first random draw.
      */
-    static getDailyContent(): Promise<DailyContent | null>;
+    static getDailyContent(bypassCache?: boolean): Promise<DailyContent | null>;
     /**
      * Returns today's word of the day along with all of its listed meanings.
      */
@@ -260,18 +265,23 @@ declare class TDK {
      * `/icerik` daily-content feed, e.g. `{ adi: "Kısaltmalar", url: "https://..." }`.
      * Note: like `getRandomWord()`, this is NOT a fixed catalog — `/icerik`
      * appears to hand back a single randomly-rotated rule per request, so two
-     * calls a second apart can return entirely different rules.
+     * calls a second apart can return entirely different rules. `bypassCache`
+     * (used internally by `getRule()`'s retry loop) forces a fresh `/icerik`
+     * draw even when `enableCache(true)` is on.
      */
-    static getKurallar(): Promise<TDKRule[]>;
+    static getKurallar(bypassCache?: boolean): Promise<TDKRule[]>;
     /**
      * Fetches the full plain-text content of a named spelling rule (matched
      * case-insensitively, substring match) from `tdk.gov.tr`. Since `/icerik`
      * hands back a single randomly-rotated rule per request (out of a pool of
      * roughly twenty) rather than a fixed catalog, a single `getKurallar()`
      * draw would rarely match a given name — this re-draws (bounded, with a
-     * short delay) until it finds a match or gives up. Returns `null` if no
-     * match turns up within the attempt budget or the matched page can't be
-     * parsed.
+     * short delay) until it finds a match or gives up. Every attempt bypasses
+     * `dailyContentCache` — without that, once `enableCache(true)` is on, all
+     * 25 attempts would just re-read the same cached `/icerik` response and
+     * could never find a rule outside whatever the first draw happened to be.
+     * Returns `null` if no match turns up within the attempt budget or the
+     * matched page can't be parsed.
      */
     static getRule(name: string): Promise<string | null>;
     /**

package/dist/index.d.ts

@@ -244,8 +244,13 @@ declare class TDK {
     static checkSpelling(word: string): Promise<SpellCheckResult>;
     /**
      * Fetches daily content (word of the day, proverbs, rules, etc).
+     * `bypassCache` skips both reading and writing `dailyContentCache` even
+     * when `enableCache(true)` is on — used by `getRule()`'s retry loop, which
+     * needs a fresh random `/icerik` draw on every attempt; without it, once
+     * caching is enabled the loop would just re-read the same cached response
+     * 25 times and could never find a rule outside that first random draw.
      */
-    static getDailyContent(): Promise<DailyContent | null>;
+    static getDailyContent(bypassCache?: boolean): Promise<DailyContent | null>;
     /**
      * Returns today's word of the day along with all of its listed meanings.
      */
@@ -260,18 +265,23 @@ declare class TDK {
      * `/icerik` daily-content feed, e.g. `{ adi: "Kısaltmalar", url: "https://..." }`.
      * Note: like `getRandomWord()`, this is NOT a fixed catalog — `/icerik`
      * appears to hand back a single randomly-rotated rule per request, so two
-     * calls a second apart can return entirely different rules.
+     * calls a second apart can return entirely different rules. `bypassCache`
+     * (used internally by `getRule()`'s retry loop) forces a fresh `/icerik`
+     * draw even when `enableCache(true)` is on.
      */
-    static getKurallar(): Promise<TDKRule[]>;
+    static getKurallar(bypassCache?: boolean): Promise<TDKRule[]>;
     /**
      * Fetches the full plain-text content of a named spelling rule (matched
      * case-insensitively, substring match) from `tdk.gov.tr`. Since `/icerik`
      * hands back a single randomly-rotated rule per request (out of a pool of
      * roughly twenty) rather than a fixed catalog, a single `getKurallar()`
      * draw would rarely match a given name — this re-draws (bounded, with a
-     * short delay) until it finds a match or gives up. Returns `null` if no
-     * match turns up within the attempt budget or the matched page can't be
-     * parsed.
+     * short delay) until it finds a match or gives up. Every attempt bypasses
+     * `dailyContentCache` — without that, once `enableCache(true)` is on, all
+     * 25 attempts would just re-read the same cached `/icerik` response and
+     * could never find a rule outside whatever the first draw happened to be.
+     * Returns `null` if no match turns up within the attempt budget or the
+     * matched page can't be parsed.
      */
     static getRule(name: string): Promise<string | null>;
     /**

package/dist/index.js

@@ -429,29 +429,37 @@ var TDK = class {
       if (mixMatch) {
         return { isCorrect: false, word, suggestion: mixMatch.dogru };
       }
-      const candidates = [
-        ...daily.syyd.map((s) => s.dogrukelime),
-        ...daily.karistirma.flatMap((s) => [s.yanlis, s.dogru]),
-        ...daily.kelime.map((k) => k.madde)
-      ];
-      let best = null;
-      for (const candidate of candidates) {
-        const distance = this.levenshtein(word.toLocaleLowerCase("tr-TR"), candidate.toLocaleLowerCase("tr-TR"));
-        if (distance > 0 && (!best || distance < best.distance)) {
-          best = { candidate, distance };
-        }
-      }
-      if (best && best.distance <= 2) {
-        return { isCorrect: false, word, suggestion: best.candidate };
+    }
+    if (this.autocompleteCache.length === 0) {
+      this.autocompleteCache = await this.fetchAutocompleteData();
+    }
+    const cleanWord = word.trim().toLocaleLowerCase("tr-TR");
+    let best = null;
+    for (const candidate of this.autocompleteCache) {
+      if (candidate.includes(" ") || candidate !== candidate.toLocaleLowerCase("tr-TR"))
+        continue;
+      const distance = this.levenshtein(cleanWord, candidate);
+      if (distance > 0 && (!best || distance < best.distance)) {
+        best = { candidate, distance };
+        if (distance === 1)
+          break;
       }
     }
+    if (best && best.distance <= 2) {
+      return { isCorrect: false, word, suggestion: best.candidate };
+    }
     return { isCorrect: false, word };
   }
   /**
    * Fetches daily content (word of the day, proverbs, rules, etc).
+   * `bypassCache` skips both reading and writing `dailyContentCache` even
+   * when `enableCache(true)` is on — used by `getRule()`'s retry loop, which
+   * needs a fresh random `/icerik` draw on every attempt; without it, once
+   * caching is enabled the loop would just re-read the same cached response
+   * 25 times and could never find a rule outside that first random draw.
    */
-  static async getDailyContent() {
-    if (this.isCacheEnabled && this.dailyContentCache)
+  static async getDailyContent(bypassCache = false) {
+    if (!bypassCache && this.isCacheEnabled && this.dailyContentCache)
       return this.dailyContentCache;
     try {
       const response = await fetch(`${this.BASE_URL}/icerik`, {
@@ -459,7 +467,7 @@ var TDK = class {
       });
       if (response.ok) {
         const data = await response.json();
-        if (this.isCacheEnabled)
+        if (!bypassCache && this.isCacheEnabled)
           this.dailyContentCache = data;
         return data;
       }
@@ -500,10 +508,12 @@ var TDK = class {
    * `/icerik` daily-content feed, e.g. `{ adi: "Kısaltmalar", url: "https://..." }`.
    * Note: like `getRandomWord()`, this is NOT a fixed catalog — `/icerik`
    * appears to hand back a single randomly-rotated rule per request, so two
-   * calls a second apart can return entirely different rules.
+   * calls a second apart can return entirely different rules. `bypassCache`
+   * (used internally by `getRule()`'s retry loop) forces a fresh `/icerik`
+   * draw even when `enableCache(true)` is on.
    */
-  static async getKurallar() {
-    const daily = await this.getDailyContent();
+  static async getKurallar(bypassCache = false) {
+    const daily = await this.getDailyContent(bypassCache);
     return daily?.kural ?? [];
   }
   /**
@@ -512,16 +522,19 @@ var TDK = class {
    * hands back a single randomly-rotated rule per request (out of a pool of
    * roughly twenty) rather than a fixed catalog, a single `getKurallar()`
    * draw would rarely match a given name — this re-draws (bounded, with a
-   * short delay) until it finds a match or gives up. Returns `null` if no
-   * match turns up within the attempt budget or the matched page can't be
-   * parsed.
+   * short delay) until it finds a match or gives up. Every attempt bypasses
+   * `dailyContentCache` — without that, once `enableCache(true)` is on, all
+   * 25 attempts would just re-read the same cached `/icerik` response and
+   * could never find a rule outside whatever the first draw happened to be.
+   * Returns `null` if no match turns up within the attempt budget or the
+   * matched page can't be parsed.
    */
   static async getRule(name) {
     if (!name || name.trim() === "")
       return null;
     const target = name.trim().toLocaleLowerCase("tr-TR");
     for (let attempt = 0; attempt < 25; attempt++) {
-      const rules = await this.getKurallar();
+      const rules = await this.getKurallar(true);
       const match = rules.find((r) => r.adi.toLocaleLowerCase("tr-TR").includes(target));
       if (match)
         return this.fetchRuleText(match.url);

package/dist/index.mjs

@@ -3,7 +3,7 @@ import {
   TDKError,
   TDKNetworkError,
   TDKValidationError
-} from "./chunk-2TA5PMVZ.mjs";
+} from "./chunk-6BTOGV2M.mjs";
 export {
   TDK,
   TDKError,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tdk-api-wrapper",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "TDK (Türk Dil Kurumu) unofficial live data API wrapper for Node.js",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/src/tdk.ts

@@ -389,8 +389,10 @@ export class TDK {
     if (results.length > 0) {
       return { isCorrect: true, word };
     }
-    
-    // 2. If not, check "sıkça yapılan yanlışlar" from DailyContent
+
+    // 2. If not, check "sıkça yapılan yanlışlar" from DailyContent — an exact
+    // match here is TDK explicitly saying "X is often confused with Y", so
+    // it's authoritative when it hits (but only 2-3 rotating entries per call).
     const daily = await this.getDailyContent();
     if (daily) {
       const syydMatch = daily.syyd.find(s => s.yanliskelime.toLocaleLowerCase("tr-TR") === word.toLocaleLowerCase("tr-TR"));
@@ -401,43 +403,49 @@ export class TDK {
       if (mixMatch) {
         return { isCorrect: false, word, suggestion: mixMatch.dogru };
       }
+    }
 
-      // 3. No exact match in TDK's fixed lists: fall back to the closest word
-      // (by edit distance) within that same small pool. This is NOT a search
-      // over the full dictionary — TDK exposes no such lookup — just a
-      // best-effort nudge using the "sık yapılan yanlışlar" data we already have.
-      const candidates = [
-        ...daily.syyd.map((s) => s.dogrukelime),
-        ...daily.karistirma.flatMap((s) => [s.yanlis, s.dogru]),
-        ...daily.kelime.map((k) => k.madde),
-      ];
-      let best: { candidate: string; distance: number } | null = null;
-      for (const candidate of candidates) {
-        const distance = this.levenshtein(word.toLocaleLowerCase("tr-TR"), candidate.toLocaleLowerCase("tr-TR"));
-        if (distance > 0 && (!best || distance < best.distance)) {
-          best = { candidate, distance };
-        }
-      }
-      if (best && best.distance <= 2) {
-        return { isCorrect: false, word, suggestion: best.candidate };
+    // 3. No exact match in TDK's curated lists: fall back to the closest
+    // headword (by edit distance) across TDK's full ~81k-word list (the same
+    // data `getSuggestions()` uses). Restricted to single-token, lowercase
+    // headwords so it doesn't suggest compounds/phrases or proper nouns.
+    if (this.autocompleteCache.length === 0) {
+      this.autocompleteCache = await this.fetchAutocompleteData();
+    }
+    const cleanWord = word.trim().toLocaleLowerCase("tr-TR");
+    let best: { candidate: string; distance: number } | null = null;
+    for (const candidate of this.autocompleteCache) {
+      if (candidate.includes(" ") || candidate !== candidate.toLocaleLowerCase("tr-TR")) continue;
+      const distance = this.levenshtein(cleanWord, candidate);
+      if (distance > 0 && (!best || distance < best.distance)) {
+        best = { candidate, distance };
+        if (distance === 1) break;
       }
     }
+    if (best && best.distance <= 2) {
+      return { isCorrect: false, word, suggestion: best.candidate };
+    }
     return { isCorrect: false, word };
   }
 
   /**
    * Fetches daily content (word of the day, proverbs, rules, etc).
+   * `bypassCache` skips both reading and writing `dailyContentCache` even
+   * when `enableCache(true)` is on — used by `getRule()`'s retry loop, which
+   * needs a fresh random `/icerik` draw on every attempt; without it, once
+   * caching is enabled the loop would just re-read the same cached response
+   * 25 times and could never find a rule outside that first random draw.
    */
-  public static async getDailyContent(): Promise<DailyContent | null> {
-    if (this.isCacheEnabled && this.dailyContentCache) return this.dailyContentCache;
-    
+  public static async getDailyContent(bypassCache = false): Promise<DailyContent | null> {
+    if (!bypassCache && this.isCacheEnabled && this.dailyContentCache) return this.dailyContentCache;
+
     try {
       const response = await fetch(`${this.BASE_URL}/icerik`, {
         headers: { "User-Agent": "TDK-API-Nodejs-Wrapper/1.0" },
       });
       if (response.ok) {
         const data = await response.json() as DailyContent;
-        if (this.isCacheEnabled) this.dailyContentCache = data;
+        if (!bypassCache && this.isCacheEnabled) this.dailyContentCache = data;
         return data;
       }
     } catch {
@@ -480,10 +488,12 @@ export class TDK {
    * `/icerik` daily-content feed, e.g. `{ adi: "Kısaltmalar", url: "https://..." }`.
    * Note: like `getRandomWord()`, this is NOT a fixed catalog — `/icerik`
    * appears to hand back a single randomly-rotated rule per request, so two
-   * calls a second apart can return entirely different rules.
+   * calls a second apart can return entirely different rules. `bypassCache`
+   * (used internally by `getRule()`'s retry loop) forces a fresh `/icerik`
+   * draw even when `enableCache(true)` is on.
    */
-  public static async getKurallar(): Promise<TDKRule[]> {
-    const daily = await this.getDailyContent();
+  public static async getKurallar(bypassCache = false): Promise<TDKRule[]> {
+    const daily = await this.getDailyContent(bypassCache);
     return daily?.kural ?? [];
   }
 
@@ -493,16 +503,19 @@ export class TDK {
    * hands back a single randomly-rotated rule per request (out of a pool of
    * roughly twenty) rather than a fixed catalog, a single `getKurallar()`
    * draw would rarely match a given name — this re-draws (bounded, with a
-   * short delay) until it finds a match or gives up. Returns `null` if no
-   * match turns up within the attempt budget or the matched page can't be
-   * parsed.
+   * short delay) until it finds a match or gives up. Every attempt bypasses
+   * `dailyContentCache` — without that, once `enableCache(true)` is on, all
+   * 25 attempts would just re-read the same cached `/icerik` response and
+   * could never find a rule outside whatever the first draw happened to be.
+   * Returns `null` if no match turns up within the attempt budget or the
+   * matched page can't be parsed.
    */
   public static async getRule(name: string): Promise<string | null> {
     if (!name || name.trim() === "") return null;
     const target = name.trim().toLocaleLowerCase("tr-TR");
 
     for (let attempt = 0; attempt < 25; attempt++) {
-      const rules = await this.getKurallar();
+      const rules = await this.getKurallar(true);
       const match = rules.find((r) => r.adi.toLocaleLowerCase("tr-TR").includes(target));
       if (match) return this.fetchRuleText(match.url);
       await this.delay(100);