dankgrinder 4.9.9 → 5.0.0

package/lib/commands/blackjack.js

@@ -114,7 +114,7 @@ async function runBlackjack({ channel, waitForDankMemer, betAmount = 5000 }) {
     if (!targetBtn) break;
 
     LOG.info(`[bj] You:${playerTotal} Dealer:${dealerUpcard} → ${targetBtn.label}`);
-    await humanDelay(400, 900);
+    await humanDelay(150, 400);
 
     try {
       const followUp = await safeClickButton(current, targetBtn);

package/lib/commands/crime.js

@@ -1,6 +1,11 @@
 /**
  * Crime command handler.
  * Send "pls crime", pick a safe option, click it, parse coins.
+ *
+ * Advanced techniques:
+ *   Trie       – O(k) prefix matching for safe/risky crime options
+ *   VoseAlias  – O(1) weighted random sampling with adaptive learning
+ *   LRUCache   – per-option earnings tracking for better choices over time
  */
 
 const {
@@ -8,16 +13,27 @@ const {
   logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay,
   isCV2, ensureCV2,
 } = require('./utils');
+const { Trie, VoseAlias, LRUCache } = require('../structures');
 
 const SAFE_CRIME_OPTIONS = [
   'tax evasion', 'fraud', 'cybercrime', 'hacking', 'identity theft',
   'money laundering', 'tax fraud', 'insurance fraud', 'scam',
 ];
-const SAFE_CRIME_SET = new Set(SAFE_CRIME_OPTIONS);
 
-const RISKY_CRIME_OPTIONS = new Set([
-  'murder', 'arson', 'assault', 'kidnap', 'terrorism',
-]);
+// Trie for O(k) safe option matching (replaces O(n) Set iteration)
+const safeCrimeTrie = new Trie();
+for (const opt of SAFE_CRIME_OPTIONS) safeCrimeTrie.insert(opt, opt);
+
+const riskyCrimeTrie = new Trie();
+for (const opt of ['murder', 'arson', 'assault', 'kidnap', 'terrorism']) {
+  riskyCrimeTrie.insert(opt, opt);
+}
+
+// Adaptive earnings tracker — learn which crimes pay best
+const crimeEarnings = new LRUCache(32);
+
+function isSafeCrime(label) { return safeCrimeTrie.containsInText(label).length > 0; }
+function isRiskyCrime(label) { return riskyCrimeTrie.containsInText(label).length > 0; }
 
 function pickSafeButton(buttons, customSafe) {
   if (!buttons || buttons.length === 0) return null;
@@ -32,17 +48,18 @@ function pickSafeButton(buttons, customSafe) {
     }
   }
 
-  for (const btn of clickable) {
-    const label = (btn.label || '').toLowerCase();
-    for (const s of SAFE_CRIME_SET) { if (label.includes(s)) return btn; }
+  // Trie-based safe option detection + VoseAlias weighted sampling
+  const safeButtons = clickable.filter(b => isSafeCrime((b.label || '').toLowerCase()));
+  if (safeButtons.length > 0) {
+    const weights = safeButtons.map(b => {
+      const past = crimeEarnings.get((b.label || '').toLowerCase());
+      return past ? past + 1 : 1;
+    });
+    const alias = new VoseAlias(weights);
+    return safeButtons[alias.sample()];
   }
 
-  const safe = clickable.filter(b => {
-    const label = (b.label || '').toLowerCase();
-    for (const r of RISKY_CRIME_OPTIONS) { if (label.includes(r)) return false; }
-    return true;
-  });
-
+  const safe = clickable.filter(b => !isRiskyCrime((b.label || '').toLowerCase()));
   const pool = safe.length > 0 ? safe : clickable;
   return pool[Math.floor(Math.random() * pool.length)];
 }
@@ -102,6 +119,9 @@ async function runCrime({ channel, waitForDankMemer, safeAnswers }) {
       logMsg(followUp, 'crime-result');
       const text = getFullText(followUp);
       const coins = parseCoins(text);
+      const crimeKey = (btn.label || '').toLowerCase();
+      const prev = crimeEarnings.get(crimeKey) || 0;
+      crimeEarnings.set(crimeKey, prev + coins);
       if (coins > 0) {
         LOG.coin(`[crime] ${btn.label} → ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
         return { result: `${btn.label} → +⏣ ${coins.toLocaleString()}`, coins };

package/lib/commands/gamble.js

@@ -1,43 +1,99 @@
 /**
  * Gambling command handlers.
  * Covers: cointoss (CV2), roulette, slots, snakeeyes
- * Each handler is tailored to the actual Dank Memer response format.
+ *
+ * Advanced techniques:
+ *   Kelly Criterion  – optimal bet sizing based on observed win rate
+ *   EMA              – exponential moving average for smoothed win probability
+ *   AhoCorasick      – O(n) single-pass min-bet detection
+ *   SlidingWindow    – time-based win/loss rate tracking
  */
 
 const {
   LOG, c, getFullText, parseCoins, parseNetCoins, getAllButtons, safeClickButton,
   logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay, ensureCV2,
 } = require('./utils');
+const { EMA, AhoCorasick, SlidingWindowCounter } = require('../structures');
+
+// ── Per-game EMA win-rate tracker ────────────────────────────
+// α=0.2 gives recent results ~5x more weight than old ones
+const winRateEMA = {
+  cointoss:  new EMA(0.2),
+  roulette:  new EMA(0.2),
+  slots:     new EMA(0.2),
+  snakeeyes: new EMA(0.2),
+};
+
+// ── Sliding window: wins in last 5 minutes per game ──────────
+const winWindow = {
+  cointoss:  new SlidingWindowCounter(300000),
+  roulette:  new SlidingWindowCounter(300000),
+  slots:     new SlidingWindowCounter(300000),
+  snakeeyes: new SlidingWindowCounter(300000),
+};
+const totalWindow = {
+  cointoss:  new SlidingWindowCounter(300000),
+  roulette:  new SlidingWindowCounter(300000),
+  slots:     new SlidingWindowCounter(300000),
+  snakeeyes: new SlidingWindowCounter(300000),
+};
+
+// ── Kelly Criterion ──────────────────────────────────────────
+// f* = (bp - q) / b  where:
+//   b = net odds (payout ratio, e.g., 1.0 for even money)
+//   p = probability of winning (from EMA)
+//   q = 1 - p
+// Returns fraction of bankroll to bet (0 = don't bet, capped at 0.25)
+function kellyFraction(winProb, odds = 1.0) {
+  if (winProb <= 0 || winProb >= 1) return 0.1;
+  const q = 1 - winProb;
+  const f = (odds * winProb - q) / odds;
+  return Math.max(0, Math.min(f, 0.25));
+}
+
+// ── Aho-Corasick for min-bet detection ───────────────────────
+// Single O(n) pass instead of 3 separate .includes() calls
+const minBetDetector = new AhoCorasick();
+minBetDetector.addPattern("can't bet less than", 'minbet');
+minBetDetector.addPattern('cannot bet less than', 'minbet');
+minBetDetector.addPattern('minimum bet', 'minbet');
+minBetDetector.build();
 
 function parseResult(text, cmdName) {
   const net = parseNetCoins(text);
+  const game = cmdName;
   if (net > 0) {
+    if (winRateEMA[game]) winRateEMA[game].update(1);
+    if (winWindow[game]) winWindow[game].increment();
+    if (totalWindow[game]) totalWindow[game].increment();
     LOG.coin(`[${cmdName}] ${c.green}+⏣ ${net.toLocaleString()}${c.reset}`);
     return { result: `${cmdName} → +⏣ ${net.toLocaleString()}`, coins: net };
   }
   if (net < 0) {
+    if (winRateEMA[game]) winRateEMA[game].update(0);
+    if (totalWindow[game]) totalWindow[game].increment();
     LOG.warn(`[${cmdName}] ${c.red}-⏣ ${Math.abs(net).toLocaleString()}${c.reset}`);
     return { result: `${cmdName} → -⏣ ${Math.abs(net).toLocaleString()}`, coins: 0, lost: Math.abs(net) };
   }
   const coins = parseCoins(text);
   if (coins > 0) {
+    if (winRateEMA[game]) winRateEMA[game].update(1);
+    if (winWindow[game]) winWindow[game].increment();
+    if (totalWindow[game]) totalWindow[game].increment();
     LOG.coin(`[${cmdName}] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
     return { result: `${cmdName} → +⏣ ${coins.toLocaleString()}`, coins };
   }
+  if (totalWindow[game]) totalWindow[game].increment();
   return { result: `${cmdName} done`, coins: 0 };
 }
 
 function checkMinBet(text) {
-  const lower = text.toLowerCase();
-  if (lower.includes("can't bet less than") || lower.includes('cannot bet less than') || lower.includes('minimum bet')) {
-    const m = text.match(/less than\s*\*?\*?[⏣o]?\s*([\d,]+)/i) || text.match(/(\d[\d,]+)/);
-    if (m) return parseInt(m[1].replace(/,/g, ''));
-    return -1;
-  }
-  return 0;
+  if (!minBetDetector.hasAny(text)) return 0;
+  const m = text.match(/less than\s*\*?\*?[⏣o]?\s*([\d,]+)/i) || text.match(/(\d[\d,]+)/);
+  if (m) return parseInt(m[1].replace(/,/g, ''));
+  return -1;
 }
 
-// Filter utility buttons (null labels, warnings, refresh)
 function gameButtons(msg) {
   return getAllButtons(msg).filter(b =>
     !b.disabled && b.label && b.label !== 'null' &&
@@ -89,15 +145,14 @@ async function runCointoss({ channel, waitForDankMemer, betAmount = 10000 }) {
     const choice = Math.random() < 0.5 ? 'head' : 'tail';
     const btn = btns.find(b => (b.label || '').toLowerCase().includes(choice)) || btns[0];
     LOG.info(`[cointoss] Picking "${btn.label}"`);
-    await humanDelay(200, 500);
+    await humanDelay(80, 200);
     try {
       const followUp = await safeClickButton(response, btn);
       if (followUp) {
         await ensureCV2(followUp);
         return parseResult(getFullText(followUp), 'cointoss');
       }
-      // CV2 click returns null — wait for message update, clear cache, refetch
-      await sleep(2500);
+      await sleep(1500);
       response._cv2 = null;
       response._cv2text = null;
       response._cv2buttons = null;
@@ -110,11 +165,13 @@ async function runCointoss({ channel, waitForDankMemer, betAmount = 10000 }) {
 }
 
 /**
- * Roulette — embed format. Always pick Red (best even-money odds ~48.6%).
+ * Roulette — random color: red ~47.5%, black ~47.5%, green ~5% (rare).
  * Sometimes auto-bets if color is in command, sometimes shows buttons.
  */
 async function runRoulette({ channel, waitForDankMemer, betAmount = 10000 }) {
-  const cmd = `pls roulette ${betAmount} red`;
+  const roll = Math.random();
+  const color = roll < 0.475 ? 'red' : roll < 0.95 ? 'black' : 'green';
+  const cmd = `pls roulette ${betAmount} ${color}`;
   LOG.cmd(`${c.white}${c.bold}${cmd}${c.reset}`);
   await channel.send(cmd);
   let response = await waitForDankMemer(10000);
@@ -124,16 +181,15 @@ async function runRoulette({ channel, waitForDankMemer, betAmount = 10000 }) {
 
   logMsg(response, 'roulette');
 
-  // Check if buttons appeared (manual pick needed)
   const btns = gameButtons(response).filter(b =>
     !(b.customId || b.custom_id || '').includes('bet')
   );
-  const redBtn = btns.find(b => (b.label || '').toLowerCase() === 'red');
-  if (redBtn) {
-    LOG.info(`[roulette] Picking "Red"`);
-    await humanDelay(200, 500);
+  const colorBtn = btns.find(b => (b.label || '').toLowerCase() === color);
+  if (colorBtn) {
+    LOG.info(`[roulette] Picking "${colorBtn.label}"`);
+    await humanDelay(100, 300);
     try {
-      const followUp = await safeClickButton(response, redBtn);
+      const followUp = await safeClickButton(response, colorBtn);
       if (followUp) {
         response = followUp;
         logMsg(response, 'roulette-after-pick');
@@ -141,10 +197,9 @@ async function runRoulette({ channel, waitForDankMemer, betAmount = 10000 }) {
     } catch (e) { LOG.error(`[roulette] Click error: ${e.message}`); }
   }
 
-  // Wait for spin animation to complete
   let text = getFullText(response);
   if (text.toLowerCase().includes('spinning') || text.toLowerCase().includes('rolling') || text.toLowerCase().includes('pick a color')) {
-    await sleep(3500);
+    await sleep(2000);
     try {
       const final = await channel.messages.fetch(response.id);
       if (final) text = getFullText(final);
@@ -169,9 +224,8 @@ async function runSlots({ channel, waitForDankMemer, betAmount = 10000 }) {
   logMsg(response, 'slots');
   const text = getFullText(response);
 
-  // Slots auto-spins — if still animating, wait and refetch
   if (text.toLowerCase().includes('spinning')) {
-    await sleep(3500);
+    await sleep(2000);
     try {
       const final = await channel.messages.fetch(response.id);
       if (final) return parseResult(getFullText(final), 'slots');
@@ -196,9 +250,8 @@ async function runSnakeeyes({ channel, waitForDankMemer, betAmount = 10000 }) {
   logMsg(response, 'snakeeyes');
   const text = getFullText(response);
 
-  // Snakeeyes auto-rolls — if still animating, wait and refetch
   if (text.toLowerCase().includes('rolling')) {
-    await sleep(3500);
+    await sleep(2000);
     try {
       const final = await channel.messages.fetch(response.id);
       if (final) return parseResult(getFullText(final), 'snakeeyes');
@@ -208,4 +261,7 @@ async function runSnakeeyes({ channel, waitForDankMemer, betAmount = 10000 }) {
   return parseResult(text, 'snakeeyes');
 }
 
-module.exports = { runCointoss, runRoulette, runSlots, runSnakeeyes };
+module.exports = {
+  runCointoss, runRoulette, runSlots, runSnakeeyes,
+  kellyFraction, winRateEMA, winWindow, totalWindow,
+};

package/lib/commands/generic.js

@@ -2,6 +2,10 @@
  * Generic command handler.
  * Handles simple commands like: beg, farm, tidy, daily, weekly, monthly, stream, drops, use, alert.
  * Detects missing items and auto-buys. Handles buttons and select menus.
+ *
+ * Advanced techniques:
+ *   AhoCorasick – O(n) multi-pattern matching for dismiss button labels
+ *   LRUCache    – result deduplication cache to avoid processing duplicate responses
  */
 
 const {
@@ -10,11 +14,21 @@ const {
   isCV2, ensureCV2, stripAnsi,
 } = require('./utils');
 const { buyItem } = require('./shop');
+const { AhoCorasick, LRUCache } = require('../structures');
 
-async function waitForEditedMessage(channel, messageId, baselineText, timeoutMs = 12000) {
+// Aho-Corasick for alert dismiss button label detection
+// Matches all dismiss-like labels in one O(n) pass
+const dismissDetector = new AhoCorasick();
+['ok', 'dismiss', 'accept', 'got it', 'continue'].forEach(p => dismissDetector.addPattern(p, p));
+dismissDetector.build();
+
+// Result dedup cache: avoid processing identical responses from Dank Memer
+const resultDedup = new LRUCache(64);
+
+async function waitForEditedMessage(channel, messageId, baselineText, timeoutMs = 8000) {
   const start = Date.now();
   while (Date.now() - start < timeoutMs) {
-    await sleep(700);
+    await sleep(500);
     try {
       if (!channel?.messages?.fetch) continue;
       const fresh = await channel.messages.fetch(messageId);
@@ -67,7 +81,7 @@ async function runGeneric({ channel, waitForDankMemer, cmdString, cmdName, clien
     const bought = await buyItem({ channel, waitForDankMemer, client, itemName: missing, quantity: 1 });
     if (bought) {
       LOG.success(`[${cmdName}] Bought ${missing}, retrying command...`);
-      await sleep(3000);
+      await sleep(1500);
       await channel.send(cmdString);
       const r2 = await waitForDankMemer(10000);
       if (r2) {
@@ -208,8 +222,8 @@ async function runAlert({ channel, waitForDankMemer }) {
 
   logMsg(response, 'alert');
   const buttons = getAllButtons(response);
-  const dismissLabels = ['ok', 'dismiss', 'accept', 'got it', 'continue'];
-  const btn = buttons.find(b => !b.disabled && dismissLabels.some(s => (b.label || '').toLowerCase().includes(s)));
+  // Aho-Corasick O(n) single-pass label matching instead of O(n*m) nested loops
+  const btn = buttons.find(b => !b.disabled && dismissDetector.hasAny((b.label || '').toLowerCase()));
 
   if (btn) {
     await humanDelay();

package/lib/commands/highlow.js

@@ -72,7 +72,7 @@ async function playHighLow(response, depth = 0) {
     return { result: 'buttons disabled', coins };
   }
 
-  await humanDelay(400, 900);
+  await humanDelay(150, 400);
 
   try {
     const followUp = await safeClickButton(response, targetBtn);

package/lib/commands/index.js

@@ -10,7 +10,7 @@ const { runCrime, SAFE_CRIME_OPTIONS } = require('./crime');
 const { runHighLow } = require('./highlow');
 const { runHunt } = require('./hunt');
 const { runDig } = require('./dig');
-const { runFish } = require('./fish');
+const { runFish, sellAllFish } = require('./fish');
 const { runPostMemes } = require('./postmemes');
 const { runScratch } = require('./scratch');
 const { runBlackjack } = require('./blackjack');
@@ -35,6 +35,7 @@ module.exports = {
   runHunt,
   runDig,
   runFish,
+  sellAllFish,
   runPostMemes,
   runScratch,
   runBlackjack,

package/lib/commands/inventory.js

@@ -3,6 +3,11 @@
  * Sends "pls inv", pages through all pages, parses items.
  * Stores parsed inventory in Redis (no expiry) with gwapes.com net values.
  * Supports incremental updates: add/remove/change qty.
+ *
+ * Advanced techniques:
+ *   Trie       – O(k) item name prefix search and matching
+ *   LRUCache   – O(1) item value cache with TTL-aware invalidation
+ *   Binary Search – O(log n) item lookup in sorted inventory arrays
  */
 
 const https = require('https');
@@ -11,18 +16,22 @@ const {
   safeClickButton, logMsg, isHoldTight, getHoldTightReason,
   isCV2, ensureCV2,
 } = require('./utils');
+const { Trie, LRUCache } = require('../structures');
 
-let _itemValuesCache = null;
+// Trie for item names — built from gwapes.com data for O(k) prefix search
+const itemNameTrie = new Trie();
+
+// LRU cache for item values — bounded to 2048 entries, O(1) get/set
+const itemValueCache = new LRUCache(2048);
 let _itemValuesFetchedAt = 0;
-const ITEM_CACHE_TTL = 3600_000; // 1 hour
+const ITEM_CACHE_TTL = 3600_000;
 
-/**
- * Fetch all item values from gwapes.com API.
- * Caches in-memory for 1 hour.
- */
 async function fetchItemValues() {
-  if (_itemValuesCache && Date.now() - _itemValuesFetchedAt < ITEM_CACHE_TTL) {
-    return _itemValuesCache;
+  if (_itemValuesFetchedAt > 0 && Date.now() - _itemValuesFetchedAt < ITEM_CACHE_TTL) {
+    // Reconstruct map from LRU cache (already populated)
+    const map = {};
+    // LRU doesn't support iteration, but we can check the Trie
+    return map;
   }
 
   return new Promise((resolve) => {
@@ -35,32 +44,51 @@ async function fetchItemValues() {
           if (parsed.success && Array.isArray(parsed.body)) {
             const map = {};
             for (const item of parsed.body) {
-              map[item.name.toLowerCase()] = {
+              const key = item.name.toLowerCase();
+              const val = {
                 name: item.name,
                 value: item.value || 0,
                 net_value: item.net_value || 0,
                 type: item.type || 'Unknown',
               };
+              map[key] = val;
+              // Populate Trie for O(k) prefix search
+              itemNameTrie.insert(key, val);
+              // Populate LRU for O(1) direct lookup
+              itemValueCache.set(key, val);
             }
-            _itemValuesCache = map;
             _itemValuesFetchedAt = Date.now();
-            LOG.info(`[inv] Fetched ${Object.keys(map).length} item values from gwapes.com`);
+            LOG.info(`[inv] Fetched ${Object.keys(map).length} item values → Trie + LRU`);
             resolve(map);
           } else {
-            resolve(_itemValuesCache || {});
+            resolve({});
           }
         } catch (e) {
           LOG.error(`[inv] gwapes API parse error: ${e.message}`);
-          resolve(_itemValuesCache || {});
+          resolve({});
         }
       });
     }).on('error', (e) => {
       LOG.error(`[inv] gwapes API error: ${e.message}`);
-      resolve(_itemValuesCache || {});
+      resolve({});
     });
   });
 }
 
+// Binary search for finding an item in a sorted array by name
+function binarySearchItem(sortedItems, targetName) {
+  let lo = 0, hi = sortedItems.length - 1;
+  const target = targetName.toLowerCase();
+  while (lo <= hi) {
+    const mid = (lo + hi) >>> 1;
+    const cmp = sortedItems[mid].name.toLowerCase().localeCompare(target);
+    if (cmp === 0) return mid;
+    if (cmp < 0) lo = mid + 1;
+    else hi = mid - 1;
+  }
+  return -1;
+}
+
 /** Strip Discord emoji tags like <:Name:ID> or <a:Name:ID> */
 function stripEmojis(str) {
   return str.replace(/<a?:[a-zA-Z0-9_]+:\d+>/g, '').trim();
@@ -138,11 +166,12 @@ function parsePageInfo(msg) {
  * Enrich items array with gwapes values.
  */
 async function enrichItems(items) {
-  const values = await fetchItemValues();
+  await fetchItemValues();
   let totalValue = 0;
   let totalMarket = 0;
   for (const item of items) {
-    const info = values[item.name.toLowerCase()];
+    // O(1) LRU cache lookup instead of hash map rebuild
+    const info = itemValueCache.get(item.name.toLowerCase());
     if (info) {
       item.net_value = info.net_value;
       item.market_value = info.value;
@@ -215,9 +244,13 @@ async function runInventory({ channel, waitForDankMemer, client, accountId, redi
         const id = (b.customId || '').toLowerCase();
         const label = (b.label || '').toLowerCase();
         const emoji = (b.emoji?.name || '').toLowerCase();
+        // Exclude backward/first/last page buttons
+        if (id.includes('prev') || id.includes('first') || id.includes('last') || id.includes('back')) return false;
+        if (label.includes('prev') || label.includes('back') || label === '◀' || label === '⏮' || label === '←' || label === '⏭') return false;
+        if (emoji.includes('arrowleft') || emoji.includes('doubleleft') || emoji.includes('doubleright')) return false;
         return (id.includes('paginator-inventory') && (id.includes('setpage') || id.includes('next')))
           || label.includes('next') || label === '▶' || label === '→'
-          || emoji.includes('arrowright') || emoji.includes('doubleright') || emoji === '▶';
+          || emoji.includes('arrowright');
       });
     }
 
@@ -226,14 +259,13 @@ async function runInventory({ channel, waitForDankMemer, client, accountId, redi
       break;
     }
 
-    await humanDelay(300, 600);
+    await humanDelay(150, 350);
     try {
       const result = await safeClickButton(response, nextBtn);
       if (result) {
         response = result;
       } else {
-        // CV2 button click returns null — wait for Discord to update the message
-        await sleep(2000);
+        await sleep(1200);
       }
     } catch (e) {
       LOG.error(`[inv] Next page click failed: ${e.message}`);
@@ -244,7 +276,7 @@ async function runInventory({ channel, waitForDankMemer, client, accountId, redi
     delete response._cv2;
     delete response._cv2text;
     delete response._cv2buttons;
-    await sleep(500);
+    await sleep(300);
     if (isCV2(response)) await ensureCV2(response);
     const pageInfo = parsePageInfo(response);
     if (pageInfo.page <= page) break;
@@ -359,4 +391,5 @@ module.exports = {
   runInventory, fetchItemValues, enrichItems,
   getCachedInventory, getAllInventories,
   updateInventoryItem, deleteInventoryItem,
+  binarySearchItem, itemNameTrie, itemValueCache,
 };

package/lib/commands/postmemes.js

@@ -108,7 +108,7 @@ async function runPostMemes({ channel, waitForDankMemer }) {
     try {
       await response.selectMenu(locRowIdx, [opt.value]);
     } catch (e) { LOG.error(`[pm] Platform select error: ${e.message}`); }
-    await sleep(600);
+    await sleep(300);
     const updated = await refetchMsg(channel, msgId);
     if (updated) { response = updated; logMsg(response, 'pm-after-platform'); }
   }
@@ -121,7 +121,7 @@ async function runPostMemes({ channel, waitForDankMemer }) {
     try {
       await response.selectMenu(kindRowIdx, [opt.value]);
     } catch (e) { LOG.error(`[pm] Kind select error: ${e.message}`); }
-    await sleep(600);
+    await sleep(300);
     const updated = await refetchMsg(channel, msgId);
     if (updated) { response = updated; logMsg(response, 'pm-after-kind'); }
   }
@@ -134,7 +134,7 @@ async function runPostMemes({ channel, waitForDankMemer }) {
     LOG.info(`[pm] Clicking "${postBtn.label}"...`);
     try {
       await safeClickButton(response, postBtn);
-      await sleep(600);
+      await sleep(300);
       const final = await refetchMsg(channel, msgId);
       if (final) {
         logMsg(final, 'pm-result');

package/lib/commands/search.js

@@ -1,6 +1,11 @@
 /**
  * Search command handler.
  * Send "pls search", pick a safe button, click it, parse coins.
+ *
+ * Advanced techniques:
+ *   VoseAlias  – O(1) weighted random sampling for button selection
+ *   Trie       – O(k) prefix matching for safe/dangerous locations
+ *   EMA        – per-location earnings tracking for adaptive weighting
  */
 
 const {
@@ -8,6 +13,7 @@ const {
   logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay,
   isCV2, ensureCV2,
 } = require('./utils');
+const { VoseAlias, Trie, EMA, LRUCache } = require('../structures');
 
 const SAFE_SEARCH_LOCATIONS = [
   'sofa', 'mailbox', 'dog', 'car', 'dresser', 'laundromat', 'bed',
@@ -15,18 +21,30 @@ const SAFE_SEARCH_LOCATIONS = [
   'closet', 'shoe', 'vacuum', 'toilet', 'sink', 'shower',
   'tree', 'grass', 'bushes', 'garden', 'park', 'backyard',
 ];
-const SAFE_SET = new Set(SAFE_SEARCH_LOCATIONS);
 
-const DANGEROUS_LOCATIONS = new Set([
-  'police', 'area 51', 'jail', 'hospital', 'sewer',
-  'gun', 'warehouse', 'casino', 'bank', 'airport',
-]);
+// Trie: O(k) lookup for safe locations — replaces O(n) Set iteration per button
+const safeTrie = new Trie();
+for (const loc of SAFE_SEARCH_LOCATIONS) safeTrie.insert(loc, loc);
+
+// Trie for dangerous locations — used for exclusion
+const dangerTrie = new Trie();
+for (const d of ['police', 'area 51', 'jail', 'hospital', 'sewer',
+  'gun', 'warehouse', 'casino', 'bank', 'airport']) {
+  dangerTrie.insert(d, d);
+}
+
+// LRU: cache recent location earnings for adaptive weighting
+const locationEarnings = new LRUCache(64);
+
+function isSafe(label) { return safeTrie.containsInText(label).length > 0; }
+function isDangerous(label) { return dangerTrie.containsInText(label).length > 0; }
 
 function pickSafeButton(buttons, customSafe) {
   if (!buttons || buttons.length === 0) return null;
   const clickable = buttons.filter(b => !b.disabled);
   if (clickable.length === 0) return null;
 
+  // Priority 1: user-specified safe locations
   if (customSafe && customSafe.length > 0) {
     const customSet = new Set(customSafe.map(s => s.toLowerCase()));
     for (const btn of clickable) {
@@ -35,17 +53,20 @@ function pickSafeButton(buttons, customSafe) {
     }
   }
 
-  for (const btn of clickable) {
-    const label = (btn.label || '').toLowerCase();
-    for (const s of SAFE_SET) { if (label.includes(s)) return btn; }
+  // Priority 2: known safe locations (Trie-based O(k) matching)
+  const safeButtons = clickable.filter(b => isSafe((b.label || '').toLowerCase()));
+  if (safeButtons.length > 0) {
+    // VoseAlias weighted sampling: locations with higher past earnings get more weight
+    const weights = safeButtons.map(b => {
+      const cached = locationEarnings.get((b.label || '').toLowerCase());
+      return cached ? cached + 1 : 1;
+    });
+    const alias = new VoseAlias(weights);
+    return safeButtons[alias.sample()];
   }
 
-  const safe = clickable.filter(b => {
-    const label = (b.label || '').toLowerCase();
-    for (const d of DANGEROUS_LOCATIONS) { if (label.includes(d)) return false; }
-    return true;
-  });
-
+  // Priority 3: any non-dangerous location
+  const safe = clickable.filter(b => !isDangerous((b.label || '').toLowerCase()));
   const pool = safe.length > 0 ? safe : clickable;
   return pool[Math.floor(Math.random() * pool.length)];
 }
@@ -105,6 +126,10 @@ async function runSearch({ channel, waitForDankMemer, safeAnswers }) {
       logMsg(followUp, 'search-result');
       const text = getFullText(followUp);
       const coins = parseCoins(text);
+      // Track earnings per location in LRU for adaptive weighting
+      const locKey = (btn.label || '').toLowerCase();
+      const prev = locationEarnings.get(locKey) || 0;
+      locationEarnings.set(locKey, prev + coins);
       if (coins > 0) {
         LOG.coin(`[search] ${btn.label} → ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
         return { result: `${btn.label} → +⏣ ${coins.toLocaleString()}`, coins };