novac 2.2.1 → 2.3.0

package/kits/kitmisc/kitdef.js

@@ -0,0 +1,2037 @@
+/**
+ * Kitmisc - Miscellaneous utilities kit
+ */
+
+// ─── BRAINFUCK ────────────────────────────────────────────────────────────────
+
+/**
+ * @param {() => Promise<number>} inputSource - async fn that resolves to a byte value (char code)
+ * @returns {{ run, cell, reset, register }}
+ */
+function makeBfObject(inputSource) {
+  const TAPE_SIZE = 30000;
+
+  let tape = new Uint8Array(TAPE_SIZE);
+  let ptr = 0;
+  const customCommands = new Map();
+
+  function reset() {
+    tape = new Uint8Array(TAPE_SIZE);
+    ptr = 0;
+  }
+
+  function register(char, handler) {
+    if (typeof char !== "string" || char.length !== 1)
+      throw new TypeError("register: char must be a single character");
+    if (typeof handler !== "function")
+      throw new TypeError("register: handler must be a function");
+    customCommands.set(char, handler);
+  }
+
+  async function run(code) {
+    const ops = Array.from(String(code));
+
+    const jumpTable = new Map();
+    const stack = [];
+    for (let i = 0; i < ops.length; i++) {
+      if (ops[i] === "[") {
+        stack.push(i);
+      } else if (ops[i] === "]") {
+        if (!stack.length) throw new SyntaxError(`Unmatched ] at position ${i}`);
+        const open = stack.pop();
+        jumpTable.set(open, i);
+        jumpTable.set(i, open);
+      }
+    }
+    if (stack.length)
+      throw new SyntaxError(`Unmatched [ at position ${stack[0]}`);
+
+    const output = [];
+    let ip = 0;
+
+    while (ip < ops.length) {
+      const op = ops[ip];
+
+      switch (op) {
+        case ">": ptr = (ptr + 1) % TAPE_SIZE; break;
+        case "<": ptr = (ptr - 1 + TAPE_SIZE) % TAPE_SIZE; break;
+        case "+": tape[ptr] = (tape[ptr] + 1) & 0xff; break;
+        case "-": tape[ptr] = (tape[ptr] - 1 + 256) & 0xff; break;
+        case ".": output.push(String.fromCharCode(tape[ptr])); break;
+        case ",": {
+          const byte = await inputSource();
+          tape[ptr] = typeof byte === "number" ? byte & 0xff : byte.charCodeAt(0);
+          break;
+        }
+        case "[": if (tape[ptr] === 0) ip = jumpTable.get(ip); break;
+        case "]": if (tape[ptr] !== 0) ip = jumpTable.get(ip); break;
+        default:
+          if (customCommands.has(op)) {
+            await customCommands.get(op)({
+              tape,
+              get ptr() { return ptr; },
+              set ptr(v) { ptr = ((v % TAPE_SIZE) + TAPE_SIZE) % TAPE_SIZE; },
+              output,
+              inputSource,
+            });
+          }
+          break;
+      }
+
+      ip++;
+    }
+
+    return output.join("");
+  }
+
+  return { run, reset, register, get cell() { return tape[ptr]; } };
+}
+
+// ─── OOK! ─────────────────────────────────────────────────────────────────────
+
+/**
+ * Ook! interpreter — BF in monkey.
+ * https://esolangs.org/wiki/Ook!
+ * @param {() => Promise<number>} inputSource
+ * @returns {{ transpile, run, reset, cell }}
+ */
+function makeOokObject(inputSource) {
+  const OOK_MAP = {
+    "Ook. Ook?": ">",
+    "Ook? Ook.": "<",
+    "Ook. Ook.": "+",
+    "Ook! Ook!": "-",
+    "Ook! Ook.": ".",
+    "Ook. Ook!": ",",
+    "Ook! Ook?": "[",
+    "Ook? Ook!": "]",
+  };
+
+  function transpile(source) {
+    const tokens = String(source).match(/Ook[.!?]/g);
+    if (!tokens) throw new SyntaxError("No Ook tokens found");
+    if (tokens.length & 1) throw new SyntaxError("Odd number of Ook tokens");
+    const bf = [];
+    for (let i = 0; i < tokens.length; i += 2) {
+      const pair = `${tokens[i]} ${tokens[i + 1]}`;
+      const cmd = OOK_MAP[pair];
+      if (!cmd) throw new SyntaxError(`Unknown Ook pair: "${pair}"`);
+      bf.push(cmd);
+    }
+    return bf.join("");
+  }
+
+  const bf = makeBfObject(inputSource);
+  return {
+    transpile,
+    async run(source) { return bf.run(transpile(source)); },
+    reset: bf.reset,
+    get cell() { return bf.cell; },
+  };
+}
+
+// ─── BEFUNGE-93 ───────────────────────────────────────────────────────────────
+
+/**
+ * Befunge-93 interpreter — 2D grid-based esoteric language.
+ * https://esolangs.org/wiki/Befunge
+ * @param {() => Promise<number>} inputSource
+ * @returns {{ run }}
+ */
+function makeBefungeObject(inputSource) {
+  const W = 80, H = 25;
+
+  async function run(source, maxSteps = 1_000_000) {
+    const lines = String(source).split("\n");
+    const grid = Array.from({ length: H }, (_, y) => {
+      const row = Array.from(lines[y] ?? "");
+      while (row.length < W) row.push(" ");
+      return row.slice(0, W);
+    });
+
+    let x = 0, y = 0, dx = 1, dy = 0;
+    const stack = [];
+    let stringMode = false;
+    const output = [];
+
+    const pop  = ()    => stack.pop() ?? 0;
+    const push = (v)   => stack.push(v | 0);
+    const wrap = (n, max) => ((n % max) + max) % max;
+
+    for (let step = 0; step < maxSteps; step++) {
+      const op = grid[y]?.[x] ?? " ";
+
+      if (stringMode) {
+        if (op === '"') stringMode = false;
+        else push(op.charCodeAt(0));
+      } else {
+        switch (op) {
+          case ">": dx =  1; dy =  0; break;
+          case "<": dx = -1; dy =  0; break;
+          case "^": dx =  0; dy = -1; break;
+          case "v": dx =  0; dy =  1; break;
+          case "?": {
+            const dirs = [[1,0],[-1,0],[0,1],[0,-1]];
+            [dx, dy] = dirs[Math.random() * 4 | 0];
+            break;
+          }
+          case "#":
+            x = wrap(x + dx, W);
+            y = wrap(y + dy, H);
+            break;
+          case '"': stringMode = true; break;
+          case "0": case "1": case "2": case "3": case "4":
+          case "5": case "6": case "7": case "8": case "9":
+            push(+op); break;
+          case "+": push(pop() + pop()); break;
+          case "-": { const b = pop(), a = pop(); push(a - b); break; }
+          case "*": push(pop() * pop()); break;
+          case "/": { const b = pop(), a = pop(); push(b === 0 ? 0 : (a / b) | 0); break; }
+          case "%": { const b = pop(), a = pop(); push(b === 0 ? 0 : a % b); break; }
+          case "!": push(pop() === 0 ? 1 : 0); break;
+          case "`": { const b = pop(), a = pop(); push(a > b ? 1 : 0); break; }
+          case ":": { const a = pop(); push(a); push(a); break; }
+          case "\\": { const b = pop(), a = pop(); push(b); push(a); break; }
+          case "$": pop(); break;
+          case ".": output.push(String(pop()) + " "); break;
+          case ",": output.push(String.fromCharCode(pop())); break;
+          case "&": {
+            const v = await inputSource();
+            push(typeof v === "number" ? v : parseInt(v) || 0);
+            break;
+          }
+          case "~": {
+            const v = await inputSource();
+            push(typeof v === "number" ? v : (String(v).charCodeAt(0) || 0));
+            break;
+          }
+          case "p": {
+            const gy = pop(), gx = pop(), val = pop();
+            if (grid[gy]) grid[gy][gx] = String.fromCharCode(val);
+            break;
+          }
+          case "g": {
+            const gy = pop(), gx = pop();
+            push((grid[gy]?.[gx] ?? " ").charCodeAt(0));
+            break;
+          }
+          case "_": dx = pop() === 0 ?  1 : -1; dy = 0; break;
+          case "|": dy = pop() === 0 ?  1 : -1; dx = 0; break;
+          case "@": return output.join("");
+          default: break;
+        }
+      }
+
+      x = wrap(x + dx, W);
+      y = wrap(y + dy, H);
+    }
+
+    throw new Error("Befunge: step limit exceeded (infinite loop?)");
+  }
+
+  return { run };
+}
+
+// ─── MARKOV CHAIN ─────────────────────────────────────────────────────────────
+
+/**
+ * Character-level Markov chain text generator.
+ * @param {number} order - context window size (default 2)
+ * @returns {{ train, generate, clear, size }}
+ */
+function makeMarkov(order = 2) {
+  const chain = new Map();
+
+  function train(text) {
+    const s = String(text);
+    for (let i = 0; i < s.length - order; i++) {
+      const key  = s.slice(i, i + order);
+      const next = s[i + order];
+      if (!chain.has(key)) chain.set(key, []);
+      chain.get(key).push(next);
+    }
+    return api;
+  }
+
+  function generate(length = 200, seed = null) {
+    const keys = Array.from(chain.keys());
+    if (!keys.length) throw new Error("Markov: not trained");
+
+    let current;
+    if (seed && seed.length >= order && chain.has(seed.slice(-order))) {
+      current = seed.slice(-order);
+    } else {
+      current = keys[Math.random() * keys.length | 0];
+    }
+
+    const result = [seed ?? current];
+
+    for (let i = 0; i < length - order; i++) {
+      const options = chain.get(current);
+      if (!options) {
+        const fallback = keys[Math.random() * keys.length | 0];
+        result.push(fallback);
+        current = fallback;
+        continue;
+      }
+      const next = options[Math.random() * options.length | 0];
+      result.push(next);
+      current = current.slice(1) + next;
+    }
+
+    return result.join("");
+  }
+
+  function clear() { chain.clear(); return api; }
+
+  const api = { train, generate, clear, get size() { return chain.size; } };
+  return api;
+}
+
+// ─── ZALGO ────────────────────────────────────────────────────────────────────
+
+// Combining characters above, through, and below
+const ZALGO_UP = [
+  ...Array.from({ length: 0x0315 - 0x0300 + 1 }, (_, i) => String.fromCharCode(0x0300 + i)),
+  ...Array.from({ length: 0x0344 - 0x033D + 1 }, (_, i) => String.fromCharCode(0x033D + i)),
+  "\u0346", "\u034A", "\u034B", "\u034C",
+  ...Array.from({ length: 0x0352 - 0x0350 + 1 }, (_, i) => String.fromCharCode(0x0350 + i)),
+  "\u0357", "\u035B",
+  ...Array.from({ length: 0x036F - 0x0363 + 1 }, (_, i) => String.fromCharCode(0x0363 + i)),
+];
+const ZALGO_MID = Array.from({ length: 0x0338 - 0x0334 + 1 }, (_, i) => String.fromCharCode(0x0334 + i));
+const ZALGO_DOWN = [
+  ...Array.from({ length: 0x0319 - 0x0316 + 1 }, (_, i) => String.fromCharCode(0x0316 + i)),
+  ...Array.from({ length: 0x0320 - 0x031C + 1 }, (_, i) => String.fromCharCode(0x031C + i)),
+  ...Array.from({ length: 0x0333 - 0x0324 + 1 }, (_, i) => String.fromCharCode(0x0324 + i)),
+  ...Array.from({ length: 0x033C - 0x0339 + 1 }, (_, i) => String.fromCharCode(0x0339 + i)),
+  "\u0345",
+  ...Array.from({ length: 0x0349 - 0x0347 + 1 }, (_, i) => String.fromCharCode(0x0347 + i)),
+  "\u034D", "\u034E",
+  ...Array.from({ length: 0x0356 - 0x0353 + 1 }, (_, i) => String.fromCharCode(0x0353 + i)),
+  "\u0359", "\u035A",
+];
+
+/**
+ * Corrupts text with Zalgo combining characters.
+ * @param {string} text
+ * @param {'mini'|'medium'|'maxi'} intensity
+ */
+function zalgoify(text, intensity = "medium") {
+  const max = { mini: 1, medium: 4, maxi: 12 }[intensity] ?? 4;
+  const pick  = (arr) => arr[Math.random() * arr.length | 0];
+  const count = ()    => Math.random() * max | 0;
+
+  return Array.from(String(text)).map(ch => {
+    if (ch === " " || ch === "\n") return ch;
+    let out = ch;
+    for (let i = 0; i < count(); i++) out += pick(ZALGO_UP);
+    for (let i = 0; i < count(); i++) out += pick(ZALGO_MID);
+    for (let i = 0; i < count(); i++) out += pick(ZALGO_DOWN);
+    return out;
+  }).join("");
+}
+
+// ─── UWUIFY ───────────────────────────────────────────────────────────────────
+
+const UWU_FACES = ["(・`ω´・)", "OwO", "UwU", ">w<", "^w^", ":3", "x3", "uwu", "owo", "(⁄ ⁄•⁄ω⁄•⁄ ⁄)"];
+
+/**
+ * UwU text transformer. Devastating.
+ * @param {string} text
+ */
+function uwuify(text) {
+  return String(text)
+    .replace(/(?:r|l)/g,       "w")
+    .replace(/(?:R|L)/g,       "W")
+    .replace(/n([aeiou])/g,    "ny$1")
+    .replace(/N([aeiou])/g,    "Ny$1")
+    .replace(/N([AEIOU])/g,    "NY$1")
+    .replace(/ove/g,           "uv")
+    .replace(/th/g,            "d")
+    .replace(/Th/g,            "D")
+    .replace(/!/g,  () => ` ${UWU_FACES[Math.random() * UWU_FACES.length | 0]}!`)
+    .replace(/\?/g, () => ` ${UWU_FACES[Math.random() * UWU_FACES.length | 0]}?`);
+}
+
+// ─── LEET SPEAK ───────────────────────────────────────────────────────────────
+
+const L33T_LEVELS = [
+  // 0 — tasteful
+  { a:"4", e:"3", i:"1", o:"0", t:"7", s:"5" },
+  // 1 — committed
+  { a:"4", b:"8", e:"3", g:"9", i:"1", l:"1", o:"0", s:"5", t:"7", z:"2" },
+  // 2 — unhinged
+  {
+    a:"@",   b:"8",   c:"(",   d:"|)",  e:"3",   f:"|=",  g:"9",   h:"|-|",
+    i:"!",   j:"_|",  k:"|<",  l:"|_",  m:"|\\/|",n:"|\\|",o:"()", p:"|>",
+    q:"(_,)",r:"|2",  s:"$",   t:"+",   u:"|_|", v:"\\/", w:"\\/\\/",
+    x:"><",  y:"`/",  z:"2",
+  },
+];
+
+/**
+ * Converts text to leet speak.
+ * @param {string} text
+ * @param {0|1|2} level - 0=tasteful, 1=committed, 2=unhinged
+ */
+function l33tspeak(text, level = 0) {
+  const map = L33T_LEVELS[Math.min(level, 2)];
+  return Array.from(String(text)).map(ch => {
+    const r = map[ch.toLowerCase()];
+    if (!r) return ch;
+    if (r.length === 1 && ch !== ch.toLowerCase()) return r.toUpperCase();
+    return r;
+  }).join("");
+}
+
+// ─── DRUNKIFY ─────────────────────────────────────────────────────────────────
+
+const DRUNK_NEIGHBORS = { a:"sq", e:"wr", i:"uo", o:"ip", u:"yo", t:"ry", s:"da", n:"bm", h:"gj", r:"ef" };
+
+/**
+ * Makes text look like it was typed by someone who should not be texting right now.
+ * @param {string} text
+ * @param {number} drunkLevel - 0.0 (stone cold sober) to 1.0 (floor is home)
+ */
+function drunkify(text, drunkLevel = 0.4) {
+  const d = Math.max(0, Math.min(1, drunkLevel));
+  const r = () => Math.random();
+  const chars = Array.from(String(text));
+
+  const result = chars.map((ch, i) => {
+    let out = ch;
+
+    // double press
+    if (r() < d * 0.25) out = ch + ch;
+
+    // random case slip
+    if (r() < d * 0.2)  out = r() < 0.5 ? out.toUpperCase() : out.toLowerCase();
+
+    // dropped character
+    if (r() < d * 0.12 && ch !== " ") out = "";
+
+    // nearby key misfire
+    if (r() < d * 0.1) {
+      const keys = DRUNK_NEIGHBORS[ch.toLowerCase()];
+      if (keys) out += keys[r() * keys.length | 0];
+    }
+
+    // transposition with next char
+    if (r() < d * 0.08 && i < chars.length - 1) out = chars[i + 1] + ch;
+
+    return out;
+  });
+
+  const suffix = d > 0.8 ? " lmaooo" : d > 0.55 ? " lmao" : d > 0.3 ? " haha" : "";
+  return result.join("") + suffix;
+}
+
+// ─── PIG LATIN ────────────────────────────────────────────────────────────────
+
+/**
+ * Converts English text to Pig Latin. Ay!
+ * @param {string} text
+ */
+function piglatin(text) {
+  const VOWEL = /^[aeiou]/i;
+  return String(text).replace(/\b([a-zA-Z]+)\b/g, (word) => {
+    if (VOWEL.test(word)) return word + "yay";
+    const m = word.match(/^([^aeiouAEIOU]*)(.+)/);
+    if (!m) return word;
+    const [, cons, rest] = m;
+    const isCapital = word[0] === word[0].toUpperCase() && /[A-Z]/.test(word[0]);
+    const stem = isCapital ? rest[0].toUpperCase() + rest.slice(1).toLowerCase() : rest;
+    return stem + cons.toLowerCase() + "ay";
+  });
+}
+
+// ─── MORSE CODE ───────────────────────────────────────────────────────────────
+
+const MORSE_ENC = {
+  a:".-",   b:"-...", c:"-.-.", d:"-..",  e:".",    f:"..-.", g:"--.",  h:"....",
+  i:"..",   j:".---", k:"-.-",  l:".-..", m:"--",   n:"-.",   o:"---",  p:".--.",
+  q:"--.-", r:".-.",  s:"...",  t:"-",    u:"..-",  v:"...-", w:".--",  x:"-..-",
+  y:"-.--", z:"--..",
+  "0":"-----","1":".----","2":"..---","3":"...--","4":"....-","5":".....",
+  "6":"-....","7":"--...","8":"---..","9":"----.",
+  ".":".-.-.-", ",":"--..--", "?":"..--..", "'":".--.--", "!":"-.-.--",
+  "/":"-..-.",  ":":"---...",  ";":"-.-.-.","=":"-...-",  "+":".-.-.",
+  "-":"-....-", "_":"..--.-",  '"':'.-..-.','@':'.--.-.', ' ':"/",
+};
+const MORSE_DEC = Object.fromEntries(Object.entries(MORSE_ENC).map(([k, v]) => [v, k]));
+
+/**
+ * Encodes text to Morse code.
+ * @param {string} text
+ * @param {{ dot?: string, dash?: string, letterSep?: string, wordSep?: string }} opts
+ */
+function morseEncode(text, opts = {}) {
+  const dot  = opts.dot       ?? ".";
+  const dash = opts.dash      ?? "-";
+  const lsep = opts.letterSep ?? " ";
+  const wsep = opts.wordSep   ?? " / ";
+
+  return Array.from(String(text).toLowerCase())
+    .map(ch => {
+      const code = MORSE_ENC[ch];
+      if (!code) return null;
+      if (ch === " ") return "\x00"; // word boundary sentinel
+      return code.replace(/\./g, dot).replace(/-/g, dash);
+    })
+    .filter(t => t !== null)
+    .reduce((acc, token) => {
+      if (token === "\x00") return acc + wsep;
+      return acc + (acc && !acc.endsWith(wsep) ? lsep : "") + token;
+    }, "");
+}
+
+/**
+ * Decodes Morse code back to text.
+ * @param {string} morse
+ */
+function morseDecode(morse) {
+  return String(morse)
+    .split(" / ")
+    .map(word => word.split(" ").map(code => MORSE_DEC[code] ?? "?").join(""))
+    .join(" ");
+}
+
+// ─── NATO PHONETIC ────────────────────────────────────────────────────────────
+
+const NATO = {
+  a:"Alpha", b:"Bravo",   c:"Charlie", d:"Delta", e:"Echo",   f:"Foxtrot",
+  g:"Golf",  h:"Hotel",   i:"India",   j:"Juliett",k:"Kilo",  l:"Lima",
+  m:"Mike",  n:"November",o:"Oscar",   p:"Papa",  q:"Quebec", r:"Romeo",
+  s:"Sierra",t:"Tango",   u:"Uniform", v:"Victor",w:"Whiskey",x:"X-ray",
+  y:"Yankee",z:"Zulu",
+  "0":"Zero","1":"One","2":"Two","3":"Three","4":"Four",
+  "5":"Five","6":"Six","7":"Seven","8":"Eight","9":"Nine",
+};
+
+/**
+ * Converts text to NATO phonetic alphabet.
+ * @param {string} text
+ */
+function natoPhonetic(text) {
+  return Array.from(String(text)).map(ch => {
+    if (ch === " ") return "[SPACE]";
+    return NATO[ch.toLowerCase()] ?? ch;
+  }).join("-");
+}
+
+// ─── COWSAY ───────────────────────────────────────────────────────────────────
+
+const COW_BODIES = {
+  default: (e) => [
+    `        \\   ^__^`,
+    `         \\  (${e})\\_______`,
+    `            (__)\\       )\\/\\`,
+    `                ||----w |`,
+    `                ||     ||`,
+  ],
+  tux: () => [
+    `   \\`,
+    `    \\`,
+    `        .--.`,
+    `       |o_o |`,
+    `       |:_/ |`,
+    `      //   \\ \\`,
+    `     (|     | )`,
+    `    /'\\_   _/\`\\`,
+    `    \\___)=(___/`,
+  ],
+  bunny: (e) => [
+    `    \\`,
+    `     \\   (\\ /)`,
+    `      \\  ( ${e[0]} )`,
+    `         (")(")`,
+  ],
+  dragon: () => [
+    `      \\                    / \\  //\\`,
+    `       \\    |\\___/|      /   \\//  \\\\`,
+    `            /0  0  \\__  /    //  | \\ \\    `,
+    `           /     /  \\/_/    //   |  \\  \\  `,
+    `           @_^_@'/   \\/_   //    |   \\   \\ `,
+    `           //_^_/     \\/_ //     |    \\    \\`,
+    `        ( //) |        \\///      |     \\     \\`,
+    `      ( / /) _|_ /   )  //       |      \\     _\\`,
+    `    ( // /) \`/|///   (  ///      |       \\   //\\`,
+    `  ( //  /) / |//     \\ ///       |        \\ //  \\`,
+    ` (///-.//  /         ///         |         ///  //`,
+    `  (//- .  /          /           |       //   //`,
+  ],
+};
+
+const COW_EYES = {
+  default: "oo", dead: "xx", wink: ";o", wide: "OO",
+  money: "$$", paranoid: "@@", greedy: "$$", shocked: "!!",
+};
+
+/**
+ * Classic cowsay — prints an ASCII cow delivering your message.
+ * @param {string} message
+ * @param {{ wrap?: number, cow?: keyof COW_BODIES, eyes?: keyof COW_EYES }} opts
+ */
+function cowsay(message, opts = {}) {
+  const wrapWidth = opts.wrap ?? 40;
+  const cowType   = opts.cow  ?? "default";
+  const eyes      = COW_EYES[opts.eyes ?? "default"] ?? "oo";
+
+  // word-wrap
+  const words = String(message).split(" ");
+  const lines = [];
+  let line = "";
+  for (const word of words) {
+    if (line && (line + " " + word).length > wrapWidth) {
+      lines.push(line);
+      line = word;
+    } else {
+      line = line ? line + " " + word : word;
+    }
+  }
+  if (line) lines.push(line);
+
+  const maxLen = Math.max(...lines.map(l => l.length));
+  const border = "-".repeat(maxLen + 2);
+  const bubble = [`  ${border}`];
+
+  if (lines.length === 1) {
+    bubble.push(`< ${lines[0].padEnd(maxLen)} >`);
+  } else {
+    lines.forEach((l, i) => {
+      const padded = l.padEnd(maxLen);
+      if (i === 0)                bubble.push(`/ ${padded} \\`);
+      else if (i === lines.length - 1) bubble.push(`\\ ${padded} /`);
+      else                        bubble.push(`| ${padded} |`);
+    });
+  }
+  bubble.push(`  ${border}`);
+
+  const bodyFn = COW_BODIES[cowType] ?? COW_BODIES.default;
+  return [...bubble, ...bodyFn(eyes)].join("\n");
+}
+
+// ─── RPN CALCULATOR ───────────────────────────────────────────────────────────
+
+/**
+ * Reverse Polish Notation calculator with extensible operator support.
+ * @returns {{ evaluate, defineOp, peek, reset, stack }}
+ */
+function makeRPN() {
+  let stack = [];
+  const customOps = new Map();
+
+  const UNARY = {
+    sqrt:  Math.sqrt,  abs:   Math.abs,   floor: Math.floor, ceil:  Math.ceil,
+    round: Math.round, log:   Math.log,   log2:  Math.log2,  log10: Math.log10,
+    sin:   Math.sin,   cos:   Math.cos,   tan:   Math.tan,   asin:  Math.asin,
+    acos:  Math.acos,  atan:  Math.atan,  neg:   x => -x,   inv:   x => 1 / x,
+    sign:  Math.sign,  trunc: Math.trunc, exp:   Math.exp,   fact:  x => {
+      if (x < 0 || !Number.isInteger(x)) return NaN;
+      let r = 1; for (let i = 2; i <= x; i++) r *= i; return r;
+    },
+  };
+
+  const BINARY = {
+    "+": (a, b) => a + b,
+    "-": (a, b) => a - b,
+    "*": (a, b) => a * b,
+    "/": (a, b) => b === 0 ? NaN : a / b,
+    "%": (a, b) => a % b,
+    "**": (a, b) => a ** b,
+    "^": (a, b) => a ^ b,          // bitwise XOR
+    "&": (a, b) => a & b,           // bitwise AND
+    "|": (a, b) => a | b,           // bitwise OR
+    ">>": (a, b) => a >> b,
+    "<<": (a, b) => a << b,
+    "max": Math.max,
+    "min": Math.min,
+    "atan2": Math.atan2,
+    "hypot": Math.hypot,
+    "gcd": (a, b) => { a = Math.abs(a); b = Math.abs(b); while (b) { [a, b] = [b, a % b]; } return a; },
+    "lcm": (a, b) => Math.abs(a * b) / BINARY.gcd(a, b),
+  };
+
+  function evaluate(expression) {
+    for (const token of String(expression).trim().split(/\s+/)) {
+      if (!token) continue;
+
+      // number literal
+      const num = Number(token);
+      if (!isNaN(num)) { stack.push(num); continue; }
+
+      // constants
+      if (token === "pi")  { stack.push(Math.PI);  continue; }
+      if (token === "e")   { stack.push(Math.E);   continue; }
+      if (token === "phi") { stack.push((1 + Math.sqrt(5)) / 2); continue; }
+      if (token === "inf") { stack.push(Infinity); continue; }
+      if (token === "nan") { stack.push(NaN);      continue; }
+
+      // stack manipulation
+      if (token === "dup") {
+        if (!stack.length) throw new Error("RPN stack underflow: dup");
+        stack.push(stack[stack.length - 1]); continue;
+      }
+      if (token === "drop") {
+        if (!stack.length) throw new Error("RPN stack underflow: drop");
+        stack.pop(); continue;
+      }
+      if (token === "swap") {
+        if (stack.length < 2) throw new Error("RPN stack underflow: swap");
+        const b = stack.pop(), a = stack.pop();
+        stack.push(b); stack.push(a); continue;
+      }
+      if (token === "over") {
+        if (stack.length < 2) throw new Error("RPN stack underflow: over");
+        stack.push(stack[stack.length - 2]); continue;
+      }
+      if (token === "rot") {
+        if (stack.length < 3) throw new Error("RPN stack underflow: rot");
+        const c = stack.pop(), b = stack.pop(), a = stack.pop();
+        stack.push(b); stack.push(c); stack.push(a); continue;
+      }
+      if (token === "clear") { stack = []; continue; }
+
+      // user ops
+      if (customOps.has(token)) {
+        const { arity, fn } = customOps.get(token);
+        if (stack.length < arity) throw new Error(`RPN stack underflow: ${token}`);
+        const args = stack.splice(-arity).reverse();
+        stack.push(fn(...args)); continue;
+      }
+
+      // unary ops
+      if (UNARY[token]) {
+        if (!stack.length) throw new Error(`RPN stack underflow: ${token}`);
+        stack.push(UNARY[token](stack.pop())); continue;
+      }
+
+      // binary ops
+      if (BINARY[token]) {
+        if (stack.length < 2) throw new Error(`RPN stack underflow: ${token}`);
+        const b = stack.pop(), a = stack.pop();
+        stack.push(BINARY[token](a, b)); continue;
+      }
+
+      throw new Error(`RPN: unknown token "${token}"`);
+    }
+
+    return stack[stack.length - 1] ?? null;
+  }
+
+  function defineOp(name, arity, fn) {
+    if (typeof name   !== "string")   throw new TypeError("defineOp: name must be string");
+    if (typeof arity  !== "number")   throw new TypeError("defineOp: arity must be number");
+    if (typeof fn     !== "function") throw new TypeError("defineOp: fn must be function");
+    customOps.set(name, { arity, fn });
+    return api;
+  }
+
+  const api = {
+    evaluate,
+    defineOp,
+    peek()  { return stack[stack.length - 1] ?? null; },
+    reset() { stack = []; return api; },
+    get stack() { return [...stack]; },
+  };
+  return api;
+}
+
+// ─── BRAINFUCK CODE GENERATOR ─────────────────────────────────────────────────
+
+/**
+ * Generates Brainfuck code that prints a given string.
+ * Uses a multiply-then-adjust strategy: sets cell[1] to `a`, loops `b` times
+ * adding `b` to cell[0], then fine-tunes. Reasonably compact output.
+ * @param {string} str
+ * @returns {string}
+ */
+function stringToBF(str) {
+  // find best (a, b, remainder) such that a*b + rem = target, minimising total ops
+  function bestMult(target) {
+    let best = { ops: Infinity, a: 0, b: 0, rem: 0 };
+    for (let a = 2; a <= 16; a++) {
+      const b   = Math.max(0, Math.round(target / a));
+      const rem = target - a * b;
+      const ops = a + b + Math.abs(rem) + 6; // setup + loop + adjust + overhead
+      if (ops < best.ops) best = { ops, a, b, rem };
+    }
+    return best;
+  }
+
+  const chars = Array.from(String(str)).map(c => c.charCodeAt(0));
+  const parts  = [];
+  let prev = 0;
+
+  for (const target of chars) {
+    const diff = target - prev;
+
+    if (target === 0) {
+      parts.push(prev > 0 ? "[-]." : ".");
+      prev = 0;
+      continue;
+    }
+
+    // close enough — just nudge
+    if (Math.abs(diff) <= 10) {
+      parts.push(diff > 0 ? "+".repeat(diff) : "-".repeat(-diff));
+      parts.push(".");
+      prev = target;
+      continue;
+    }
+
+    // multiply strategy: uses cell[0]=output, cell[1]=scratch
+    // pattern: [zero cell0] >aaa[<bbb...>-]< [adjust] .
+    const { a, b, rem } = bestMult(target);
+    const zero   = prev > 0 ? "[-]" : "";
+    const setA   = "+".repeat(a);
+    const addB   = b >= 0 ? "+".repeat(b) : "-".repeat(-b);
+    const adjust = rem >= 0 ? "+".repeat(rem) : "-".repeat(-rem);
+
+    parts.push(`${zero}>${setA}[<${addB}>-]<${adjust}.`);
+    prev = target;
+  }
+
+  return parts.join("");
+}
+
+// ─── FAKE LOADER ──────────────────────────────────────────────────────────────
+
+/**
+ * Async generator that yields fake-but-convincing progress updates.
+ * Pair with process.stdout.write or a terminal UI for maximum deception.
+ * @param {string[]} steps - step labels
+ * @param {number} minMs
+ * @param {number} maxMs
+ * @yields {{ step, index, total, percent, bar, done }}
+ */
+async function* fakeLoader(steps, minMs = 80, maxMs = 500) {
+  const BAR = 24;
+  const total = steps.length;
+
+  for (let i = 0; i < total; i++) {
+    await new Promise(r => setTimeout(r, minMs + Math.random() * (maxMs - minMs)));
+
+    const percent = Math.round(((i + 1) / total) * 100);
+    const filled  = Math.round(((i + 1) / total) * BAR);
+
+    yield {
+      step:    steps[i],
+      index:   i,
+      total,
+      percent,
+      bar:     "█".repeat(filled) + "░".repeat(BAR - filled),
+      done:    i === total - 1,
+    };
+  }
+}
+
+// ─── ELIZA ────────────────────────────────────────────────────────────────────
+
+/**
+ * Classic ELIZA psychotherapist chatbot (Weizenbaum, 1966).
+ * @returns {{ chat }}
+ */
+function makeEliza() {
+  const REFLECT = {
+    "i am": "you are", "i was": "you were", "i": "you", "my": "your",
+    "me": "you", "you are": "I am", "you were": "I was", "your": "my",
+    "you": "I", "i've": "you've", "i'd": "you'd", "i'll": "you'll",
+    "i'm": "you're",
+  };
+
+  const RULES = [
+    [/i need (.+)/i, [
+      "Why do you need {1}?",
+      "Would it really help you to get {1}?",
+      "Are you certain you need {1}?",
+    ]],
+    [/why don'?t you (.+)/i, [
+      "Do you think I don't {1}?",
+      "Perhaps I will {1} in time.",
+      "Should I {1}?",
+    ]],
+    [/why can'?t i (.+)/i, [
+      "Do you think you should be able to {1}?",
+      "If you could {1}, what would that change?",
+      "Have you really tried?",
+    ]],
+    [/i can'?t (.+)/i, [
+      "How do you know you can't {1}?",
+      "Perhaps you could {1} if you approached it differently.",
+      "What would it take for you to {1}?",
+    ]],
+    [/i am (.+)/i, [
+      "How long have you been {1}?",
+      "Do you believe it is normal to be {1}?",
+      "How do you feel about being {1}?",
+    ]],
+    [/i'?m (.+)/i, [
+      "How does being {1} make you feel?",
+      "Do you enjoy being {1}?",
+      "Why do you tell me you're {1}?",
+    ]],
+    [/i feel (.+)/i, [
+      "Tell me more about feeling {1}.",
+      "Do you often feel {1}?",
+      "When do you usually feel {1}?",
+    ]],
+    [/my (.+) is (.+)/i, [
+      "Tell me more about your {1}.",
+      "Why is your {1} important to you?",
+      "What does it mean that your {1} is {2}?",
+    ]],
+    [/my (.+)/i, [
+      "Your {1}?",
+      "Tell me more about your {1}.",
+      "Why do you bring up your {1}?",
+    ]],
+    [/you are (.+)/i, [
+      "What makes you think I am {1}?",
+      "Does it please you to think of me as {1}?",
+    ]],
+    [/you'?re (.+)/i, [
+      "Why do you say I'm {1}?",
+      "What makes you think I'm {1}?",
+    ]],
+    [/sorry/i, [
+      "There are many times when no apology is needed.",
+      "What feelings do you have when you apologize?",
+    ]],
+    [/hello|hi|hey/i, [
+      "Hello. How are you feeling today?",
+      "Hi there. What's on your mind?",
+      "Greetings. Please tell me about yourself.",
+    ]],
+    [/i think (.+)/i, [
+      "Do you really think so?",
+      "But you're not entirely sure {1}?",
+      "Do others share that view?",
+    ]],
+    [/i want (.+)/i, [
+      "What would it mean if you got {1}?",
+      "Why do you want {1}?",
+      "Suppose you got {1} — then what?",
+    ]],
+    [/dream/i, [
+      "What does that dream suggest to you?",
+      "Have you ever had that dream before?",
+      "What persons appear in your dreams?",
+    ]],
+    [/yes/i, [
+      "You seem quite certain.",
+      "I see. Can you elaborate?",
+      "OK. But can you expand on that?",
+    ]],
+    [/no/i, [
+      "Why not?",
+      "You seem quite certain.",
+      "Are you saying no just to be safe?",
+    ]],
+    [/always/i, [
+      "Can you think of a specific example?",
+      "Really — always?",
+      "When was the last time?",
+    ]],
+    [/never/i, [
+      "Never? Are you sure?",
+      "Not even once?",
+      "Why do you think that is?",
+    ]],
+    [/quit|bye|goodbye|exit/i, [
+      "Goodbye. It was nice talking to you.",
+      "Farewell. I hope I've been of some help.",
+      "Goodbye! Come back any time.",
+    ]],
+    [/(.+)/i, [
+      "Please tell me more.",
+      "Can you elaborate on that?",
+      "Why do you say that?",
+      "I see.",
+      "Very interesting.",
+      "How does that make you feel?",
+      "Let's change focus a bit. Tell me about your family.",
+      "How do you feel when you say that?",
+    ]],
+  ];
+
+  function reflect(text) {
+    // longest-match substitution to avoid partial replacements
+    const words = text.split(/\b/);
+    return words.map((w, i) => {
+      const lower = w.toLowerCase();
+      const twoWord = (words[i - 1] ?? "").toLowerCase() + lower;
+      if (REFLECT[twoWord]) return REFLECT[twoWord];
+      return REFLECT[lower] ?? w;
+    }).join("");
+  }
+
+  function chat(input) {
+    const text = String(input).trim();
+    for (const [pattern, responses] of RULES) {
+      const m = text.match(pattern);
+      if (m) {
+        const template = responses[Math.random() * responses.length | 0];
+        return template.replace(/\{(\d+)\}/g, (_, idx) =>
+          reflect((m[+idx] ?? "").trim())
+        );
+      }
+    }
+    return "Please tell me more.";
+  }
+
+  return { chat };
+}
+
+// ─── ROT-N / VIGENÈRE ─────────────────────────────────────────────────────────
+
+/**
+ * ROT-N cipher (default ROT13).
+ * @param {string} text
+ * @param {number} n
+ */
+function rotN(text, n = 13) {
+  n = ((n % 26) + 26) % 26;
+  return String(text).replace(/[a-zA-Z]/g, ch => {
+    const base = ch >= "a" ? 97 : 65;
+    return String.fromCharCode((ch.charCodeAt(0) - base + n) % 26 + base);
+  });
+}
+
+/**
+ * Vigenère cipher encode.
+ * @param {string} text
+ * @param {string} key
+ */
+function vigenereEncode(text, key) {
+  const k = String(key).toLowerCase().replace(/[^a-z]/g, "");
+  if (!k.length) throw new Error("vigenereEncode: key must contain letters");
+  let ki = 0;
+  return String(text).replace(/[a-zA-Z]/g, ch => {
+    const base  = ch >= "a" ? 97 : 65;
+    const shift = k.charCodeAt(ki++ % k.length) - 97;
+    return String.fromCharCode((ch.charCodeAt(0) - base + shift) % 26 + base);
+  });
+}
+
+/**
+ * Vigenère cipher decode.
+ * @param {string} text
+ * @param {string} key
+ */
+function vigenereDecode(text, key) {
+  const k = String(key).toLowerCase().replace(/[^a-z]/g, "");
+  if (!k.length) throw new Error("vigenereDecode: key must contain letters");
+  let ki = 0;
+  return String(text).replace(/[a-zA-Z]/g, ch => {
+    const base  = ch >= "a" ? 97 : 65;
+    const shift = k.charCodeAt(ki++ % k.length) - 97;
+    return String.fromCharCode((ch.charCodeAt(0) - base - shift + 26) % 26 + base);
+  });
+}
+
+// ─── RUN-LENGTH ENCODING ──────────────────────────────────────────────────────
+
+/**
+ * Run-length encode a string.  "aaabbc" → "3a2bc"
+ * @param {string} str
+ */
+function runLengthEncode(str) {
+  if (!str.length) return "";
+  const out = [];
+  let count = 1;
+  for (let i = 1; i <= str.length; i++) {
+    if (i < str.length && str[i] === str[i - 1]) {
+      count++;
+    } else {
+      out.push(count > 1 ? `${count}${str[i - 1]}` : str[i - 1]);
+      count = 1;
+    }
+  }
+  return out.join("");
+}
+
+/**
+ * Decode a run-length encoded string.  "3a2bc" → "aaabbc"
+ * @param {string} str
+ */
+function runLengthDecode(str) {
+  return String(str).replace(/(\d+)([^0-9])/g, (_, n, ch) => ch.repeat(+n));
+}
+
+// ─── BASE CONVERSION ──────────────────────────────────────────────────────────
+
+const BASE_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+/";
+
+/**
+ * Converts an integer to a string in the given base (2–64).
+ * @param {number} n
+ * @param {number} base
+ */
+function toBase(n, base = 16) {
+  if (base < 2 || base > 64) throw new RangeError("toBase: base must be 2–64");
+  if (!Number.isInteger(n))   throw new TypeError("toBase: n must be an integer");
+  if (n === 0) return "0";
+  const sign   = n < 0 ? "-" : "";
+  let   mag    = Math.abs(n);
+  const digits = [];
+  while (mag > 0) { digits.unshift(BASE_CHARS[mag % base]); mag = Math.floor(mag / base); }
+  return sign + digits.join("");
+}
+
+/**
+ * Parses a base-N string back to a number.
+ * @param {string} str
+ * @param {number} base
+ */
+function fromBase(str, base = 16) {
+  if (base < 2 || base > 64) throw new RangeError("fromBase: base must be 2–64");
+  const s    = String(str).trim();
+  const sign = s[0] === "-" ? -1 : 1;
+  const body = s.replace(/^-/, "");
+  let   result = 0;
+  for (const ch of body) {
+    const val = BASE_CHARS.indexOf(ch);
+    if (val === -1 || val >= base) throw new SyntaxError(`fromBase: invalid char "${ch}" for base ${base}`);
+    result = result * base + val;
+  }
+  return sign * result;
+}
+
+// ─── DJB2 HASH ────────────────────────────────────────────────────────────────
+
+/**
+ * DJB2 hash — Dan Bernstein's classic string hash. Fast, non-cryptographic.
+ * Returns a 32-bit unsigned integer.
+ * @param {string} str
+ * @param {number} seed
+ */
+function hashDJB2(str, seed = 5381) {
+  let hash = seed >>> 0;
+  for (let i = 0; i < str.length; i++) {
+    hash = (((hash << 5) + hash) + str.charCodeAt(i)) >>> 0;
+  }
+  return hash;
+}
+
+// ─── WEIGHTED RANDOM ─────────────────────────────────────────────────────────
+
+/**
+ * Weighted random picker.
+ * @param {Array<{ value: any, weight: number }>} items
+ * @returns {{ pick, add, clear }}
+ *
+ * @example
+ * const loot = makeWeightedRandom([
+ *   { value: 'common sword', weight: 70 },
+ *   { value: 'rare shield',  weight: 25 },
+ *   { value: 'legendary orb',weight: 5  },
+ * ]);
+ * loot.pick(); // → "common sword" most of the time
+ */
+function makeWeightedRandom(items = []) {
+  let pool = items.map(({ value, weight }) => ({ value, weight: Math.max(0, weight) }));
+
+  function pick(count = 1) {
+    if (!pool.length) throw new Error("WeightedRandom: pool is empty");
+    const total = pool.reduce((s, i) => s + i.weight, 0);
+    if (total <= 0) throw new Error("WeightedRandom: all weights are zero");
+
+    const results = [];
+    for (let c = 0; c < count; c++) {
+      let r = Math.random() * total;
+      for (const item of pool) {
+        r -= item.weight;
+        if (r <= 0) { results.push(item.value); break; }
+      }
+    }
+    return count === 1 ? results[0] : results;
+  }
+
+  function add(value, weight) {
+    pool.push({ value, weight: Math.max(0, weight) });
+    return api;
+  }
+
+  function clear() { pool = []; return api; }
+
+  const api = { pick, add, clear, get size() { return pool.length; } };
+  return api;
+}
+
+// ─── MAGIC 8-BALL ─────────────────────────────────────────────────────────────
+
+const EIGHT_BALL_DEFAULTS = {
+  positive: [
+    "It is certain.",
+    "It is decidedly so.",
+    "Without a doubt.",
+    "Yes, definitely.",
+    "You may rely on it.",
+    "As I see it, yes.",
+    "Most likely.",
+    "Outlook good.",
+    "Yes.",
+    "Signs point to yes.",
+  ],
+  neutral: [
+    "Reply hazy, try again.",
+    "Ask again later.",
+    "Better not tell you now.",
+    "Cannot predict now.",
+    "Concentrate and ask again.",
+  ],
+  negative: [
+    "Don't count on it.",
+    "My reply is no.",
+    "My sources say no.",
+    "Outlook not so good.",
+    "Very doubtful.",
+  ],
+};
+
+/**
+ * Magic 8-ball with fully customisable response pools.
+ *
+ * @param {object} [opts]
+ * @param {string[]} [opts.positive]  - custom positive responses (replaces defaults)
+ * @param {string[]} [opts.neutral]   - custom neutral responses (replaces defaults)
+ * @param {string[]} [opts.negative]  - custom negative responses (replaces defaults)
+ * @param {number}   [opts.posWeight] - relative weight of positive pool (default 10)
+ * @param {number}   [opts.neuWeight] - relative weight of neutral pool  (default 5)
+ * @param {number}   [opts.negWeight] - relative weight of negative pool (default 5)
+ *
+ * @returns {{
+ *   ask,
+ *   add,
+ *   remove,
+ *   list,
+ *   setWeights,
+ *   history,
+ *   clearHistory
+ * }}
+ *
+ * @example
+ * const ball = make8Ball({
+ *   positive: ['Ship it.', 'Merge without review.'],
+ *   negative: ['Revert everything.', 'Have you tried turning it off?'],
+ *   neutral:  ['Check the logs.'],
+ * });
+ * ball.ask('Will this deploy succeed?');
+ * // → { question: '...', response: 'Ship it.', tone: 'positive' }
+ */
+function make8Ball(opts = {}) {
+  const pools = {
+    positive: [...(opts.positive ?? EIGHT_BALL_DEFAULTS.positive)],
+    neutral:  [...(opts.neutral  ?? EIGHT_BALL_DEFAULTS.neutral)],
+    negative: [...(opts.negative ?? EIGHT_BALL_DEFAULTS.negative)],
+  };
+
+  let weights = {
+    positive: opts.posWeight ?? 10,
+    neutral:  opts.neuWeight ?? 5,
+    negative: opts.negWeight ?? 5,
+  };
+
+  const log = [];
+
+  /**
+   * Ask the ball a question.
+   * @param {string} [question]
+   * @returns {{ question: string, response: string, tone: 'positive'|'neutral'|'negative' }}
+   */
+  function ask(question = "") {
+    const tones  = /** @type {const} */ (["positive", "neutral", "negative"]);
+    const total  = tones.reduce((s, t) => s + (pools[t].length ? weights[t] : 0), 0);
+
+    if (total === 0) throw new Error("8-ball: all response pools are empty");
+
+    let r = Math.random() * total;
+    let tone = tones[tones.length - 1];
+    for (const t of tones) {
+      if (!pools[t].length) continue;
+      r -= weights[t];
+      if (r <= 0) { tone = t; break; }
+    }
+
+    const pool     = pools[tone];
+    const response = pool[Math.random() * pool.length | 0];
+    const entry    = { question: String(question), response, tone };
+    log.push(entry);
+    return entry;
+  }
+
+  /**
+   * Add one or more custom responses to a pool.
+   * @param {'positive'|'neutral'|'negative'} tone
+   * @param {...string} responses
+   */
+  function add(tone, ...responses) {
+    if (!pools[tone]) throw new TypeError(`8-ball: unknown tone "${tone}" — use positive, neutral, or negative`);
+    for (const r of responses) {
+      if (typeof r !== "string" || !r.trim()) throw new TypeError("8-ball: responses must be non-empty strings");
+      pools[tone].push(r.trim());
+    }
+    return api;
+  }
+
+  /**
+   * Remove a response from a pool by exact text or index.
+   * @param {'positive'|'neutral'|'negative'} tone
+   * @param {string|number} target - exact response text or 0-based index
+   */
+  function remove(tone, target) {
+    if (!pools[tone]) throw new TypeError(`8-ball: unknown tone "${tone}"`);
+    const pool = pools[tone];
+    const idx  = typeof target === "number"
+      ? target
+      : pool.findIndex(r => r === target);
+    if (idx < 0 || idx >= pool.length) throw new RangeError(`8-ball: response not found in "${tone}" pool`);
+    pool.splice(idx, 1);
+    return api;
+  }
+
+  /**
+   * List all responses, optionally filtered by tone.
+   * @param {'positive'|'neutral'|'negative'|undefined} tone
+   */
+  function list(tone) {
+    if (tone) {
+      if (!pools[tone]) throw new TypeError(`8-ball: unknown tone "${tone}"`);
+      return [...pools[tone]];
+    }
+    return {
+      positive: [...pools.positive],
+      neutral:  [...pools.neutral],
+      negative: [...pools.negative],
+    };
+  }
+
+  /**
+   * Adjust the relative likelihood of each tone being picked.
+   * @param {{ positive?: number, neutral?: number, negative?: number }} w
+   */
+  function setWeights(w) {
+    for (const [tone, val] of Object.entries(w)) {
+      if (!pools[tone]) throw new TypeError(`8-ball: unknown tone "${tone}"`);
+      if (typeof val !== "number" || val < 0) throw new RangeError("8-ball: weights must be non-negative numbers");
+      weights[tone] = val;
+    }
+    return api;
+  }
+
+  function clearHistory() { log.length = 0; return api; }
+
+  const api = {
+    ask,
+    add,
+    remove,
+    list,
+    setWeights,
+    clearHistory,
+    get history() { return [...log]; },
+    get counts()  { return { positive: pools.positive.length, neutral: pools.neutral.length, negative: pools.negative.length }; },
+  };
+  return api;
+}
+
+// ─── EXPORTS ──────────────────────────────────────────────────────────────────
+
+let kitdef = {
+  // esoteric language runtimes
+  Brainfuck:       makeBfObject,
+  Ook:             makeOokObject,
+  Befunge:         makeBefungeObject,
+
+  // text transformers
+  zalgoify,
+  uwuify,
+  l33tspeak,
+  drunkify,
+  piglatin,
+  rotN,
+  vigenereEncode,
+  vigenereDecode,
+
+  // encoding / decoding
+  morseEncode,
+  morseDecode,
+  natoPhonetic,
+  runLengthEncode,
+  runLengthDecode,
+  toBase,
+  fromBase,
+
+  // generators / output
+  cowsay,
+  stringToBF,
+  fakeLoader,
+
+  // hashing & randomness
+  hashDJB2,
+
+  // stateful factories
+  Markov:          makeMarkov,
+  RPN:             makeRPN,
+  Eliza:           makeEliza,
+  WeightedRandom:  makeWeightedRandom,
+  EightBall:       make8Ball,
+};
+// ─── CORPORATE BUZZWORD GENERATOR ────────────────────────────────────────────
+
+const BUZZ_VERBS  = ["leverage","synergize","disrupt","pivot","ideate","strategize","streamline","democratize","incentivize","operationalize","monetize","gamify","productize","evangelize","optimize","holistically align","circle back on","take offline","unpack","double-click on"];
+const BUZZ_ADJ    = ["agile","scalable","next-generation","best-in-class","bleeding-edge","robust","mission-critical","end-to-end","data-driven","cloud-native","customer-centric","proactive","value-added","cross-functional","omni-channel","disruptive","innovative","paradigm-shifting","frictionless","hyper-focused"];
+const BUZZ_NOUNS  = ["synergies","stakeholders","deliverables","bandwidth","ecosystems","KPIs","touchpoints","verticals","pain points","low-hanging fruit","core competencies","value propositions","thought leadership","learnings","headwinds","run rate","north star","needle","flywheel","DNA"];
+
+const _pick = (arr) => arr[Math.random() * arr.length | 0];
+
+/**
+ * Generates a sentence of meaningless corporate speak.
+ * Perfect for your next all-hands.
+ * @param {number} count - number of sentences (default 1)
+ */
+function buzzword(count = 1) {
+  const sentence = () =>
+    `We need to ${_pick(BUZZ_VERBS)} our ${_pick(BUZZ_ADJ)} ${_pick(BUZZ_NOUNS)} `+
+    `to ${_pick(BUZZ_VERBS)} ${_pick(BUZZ_ADJ)} ${_pick(BUZZ_NOUNS)}.`;
+  return Array.from({ length: count }, sentence).join(" ");
+}
+
+// ─── EXCUSE GENERATOR ────────────────────────────────────────────────────────
+
+const EXCUSE_WHO   = ["the intern","Jenkins","a cosmic ray","npm","the PM","DNS","a rogue semicolon","Schrödinger's merge conflict","the on-call engineer","a passing seagull","vim","the garbage collector","WiFi","a solar flare","the load balancer"];
+const EXCUSE_WHAT  = ["deleted","corrupted","silently dropped","reordered","base64-encoded","null-coalesced","round-tripped","monkey-patched","accidentally memoized","rate-limited","hot-reloaded","race-conditioned","undefined-behavioured","recursively exploded","sharded incorrectly"];
+const EXCUSE_NOUN  = ["the database","production","the config","main","the cache","our entire test suite","the Docker socket","a single byte","the schema","every environment variable","the API contract","the feature flag","the connection pool","a load-bearing comment","the seed data"];
+const EXCUSE_WHY   = ["during a routine deploy","right before the demo","at 4:59 PM on Friday","while the CTO was watching","in UTC but we stored it in EST","because of a type coercion","due to a comment that was actually load-bearing","thanks to an implicit toString()","mid-standup","via a regex that looked fine","because NaN !== NaN","after a perfectly innocent refactor","when we upgraded a minor version","despite it working locally","for compliance reasons"];
+
+/**
+ * Generates a plausible-sounding engineering excuse.
+ * For postmortems, stand-ups, and general survival.
+ */
+function excuse() {
+  return `${_pick(EXCUSE_WHO)} ${_pick(EXCUSE_WHAT)} ${_pick(EXCUSE_NOUN)} ${_pick(EXCUSE_WHY)}.`;
+}
+
+// ─── COMMIT MESSAGE GENERATOR ────────────────────────────────────────────────
+
+const COMMIT_VERBS = ["fix","fix","fix","fix","fixup","oops","revert","add","remove","update","refactor","hopefully fix","finally fix","maybe fix","WIP:","TEMP:","DO NOT MERGE:","please work","ugh,"];
+const COMMIT_NOUNS = ["thing","stuff","that thing","the bug","it","everything","nothing","the build","tests","types","linting","the whatever","that PR comment","the CI","the flaky test","the import order","trailing whitespace","a typo","the typo I introduced while fixing the first typo","merge conflicts"];
+const COMMIT_SUFFIX = ["","","","","","","(again)","(for real this time)","(I think)","(don't ask)","(sorry)","(pls review fast)","(see slack)","(it's 2am)","(this is fine)","🙏","💀","???","[skip ci]","-- will explain later"];
+
+/**
+ * Generates a realistic git commit message.
+ */
+function commitMessage() {
+  return `${_pick(COMMIT_VERBS)} ${_pick(COMMIT_NOUNS)} ${_pick(COMMIT_SUFFIX)}`.trim();
+}
+
+// ─── VARIABLE NAME GENERATOR ──────────────────────────────────────────────────
+
+const VAR_PREFIXES = ["temp","temp2","temp_final","final","final2","actualFinal","realFinal","data","result","res","val","value","thing","stuff","foo","bar","baz","x","x2","myVar","theVar","thisVar","thatVar","newVar","oldVar"];
+const VAR_SUFFIXES = ["","New","2","Final","Temp","Copy","Backup","Fixed","Updated","V2","Again","Real","Actual","Better","Good","Bad","Test","Prod","Tmp","Bak"];
+
+/**
+ * Generates the kind of variable name that gets left in production.
+ */
+function badVarName() {
+  return _pick(VAR_PREFIXES) + _pick(VAR_SUFFIXES);
+}
+
+// ─── HOROSCOPE FOR DEVELOPERS ────────────────────────────────────────────────
+
+const HOROSCOPE_SIGNS = ["Aries","Taurus","Gemini","Cancer","Leo","Virgo","Libra","Scorpio","Sagittarius","Capricorn","Aquarius","Pisces"];
+const HOROSCOPE_EVENTS = [
+  "A null pointer exception looms on the horizon.",
+  "Mercury is in retrograde. Do not deploy.",
+  "The stars suggest your unit tests are lying to you.",
+  "A senior engineer will leave a one-word comment on your PR: 'Why?'",
+  "You will spend four hours debugging only to find a missing semicolon.",
+  "An unexpected refactor will consume your entire sprint.",
+  "The linter gods are displeased. Offer a sacrifice of trailing whitespace.",
+  "Your branch will conflict with main before you even push.",
+  "Someone will reopen a bug you closed as 'works as designed.'",
+  "A meeting that could have been an email will consume your afternoon.",
+  "npm install will betray you today.",
+  "You will Google the same thing you Googled yesterday.",
+  "The documentation lies. It always has.",
+  "Production will go down exactly when you step away from your desk.",
+  "Your local environment works. That's the last time it will.",
+];
+
+/**
+ * Reads your developer horoscope. Unsettlingly accurate.
+ * @param {string} [sign] - zodiac sign, or random if omitted
+ */
+function devHoroscope(sign) {
+  const s = sign ?? _pick(HOROSCOPE_SIGNS);
+  const e = Array.from({ length: 2 + (Math.random() * 2 | 0) }, () => _pick(HOROSCOPE_EVENTS));
+  return `✨ ${s}: ${[...new Set(e)].join(" ")}`;
+}
+
+// ─── ENTERPRISE FUNCTION NAMER ────────────────────────────────────────────────
+
+const ENT_VERBS  = ["initialize","instantiate","execute","invoke","perform","process","orchestrate","facilitate","coordinate","aggregate","normalize","serialize","deserialize","hydrate","dehydrate","transform","validate","sanitize","propagate","reconcile"];
+const ENT_NOUNS  = ["Entity","Manager","Handler","Factory","Provider","Service","Repository","Controller","Processor","Orchestrator","Facilitator","Coordinator","Aggregator","Transformer","Validator","Sanitizer","Propagator","Reconciler","Adapter","Decorator"];
+const ENT_SUFFIX = ["ForCurrentUser","WithContext","Async","Safely","Recursively","Lazily","Eagerly","Idempotently","AtomicTransaction","WithRetry","AndCache","OrFallback","IfNeeded","WhenReady","InBackground"];
+
+/**
+ * Generates a perfectly enterprise-grade function name.
+ * Six words minimum. Means nothing.
+ */
+function enterpriseFunctionName() {
+  return `${_pick(ENT_VERBS)}${_pick(ENT_NOUNS)}${_pick(ENT_NOUNS)}${_pick(ENT_SUFFIX)}`;
+}
+
+// ─── KEYBOARD SMASH DETECTOR ─────────────────────────────────────────────────
+
+/**
+ * Determines if a string is someone smashing their keyboard.
+ * Uses a sophisticated statistical model (it isn't).
+ * @param {string} str
+ * @returns {{ isSmash: boolean, confidence: number, verdict: string }}
+ */
+function detectKeyboardSmash(str) {
+  const s        = String(str).toLowerCase();
+  const unique   = new Set(s.replace(/\s/g,"")).size;
+  const len      = s.replace(/\s/g,"").length;
+  const alpha    = (s.match(/[a-z]/g) ?? []).length;
+  const avgFreq  = len / (unique || 1);
+  const homeRow  = (s.match(/[asdfghjkl;]/g) ?? []).length / (alpha || 1);
+  const score    = (avgFreq * 0.4 + homeRow * 3 + (len > 8 ? 1 : 0) * 0.5) / 4;
+  const confidence = Math.min(1, Math.max(0, score));
+  const isSmash  = confidence > 0.4;
+  const verdicts = isSmash
+    ? ["Yep, that's a smash.","Classic keyboard smash.","Your keyboard felt that.","Forensic analysis: smash.","Has anyone checked on you?"]
+    : ["Looks intentional (barely).","Questionable but coherent.","I'll allow it.","Could be a variable name.","Technically words."];
+  return { isSmash, confidence: +confidence.toFixed(2), verdict: _pick(verdicts) };
+}
+
+// ─── SARCASM DETECTOR ────────────────────────────────────────────────────────
+
+/**
+ * Detects sarcasm in text. Extremely unreliable, as nature intended.
+ * @param {string} text
+ * @returns {{ sarcastic: boolean, confidence: number, reason: string }}
+ */
+function detectSarcasm(text) {
+  const s = String(text).toLowerCase();
+  let score = 0;
+  const reasons = [];
+
+  if (/oh great|oh sure|wow thanks|fantastic|wonderful|lovely|brilliant/i.test(s)) { score += 0.4; reasons.push("suspicious enthusiasm"); }
+  if (/totally|definitely|absolutely|obviously|clearly/i.test(s)) { score += 0.2; reasons.push("over-affirmation"); }
+  if (/\.\.\./g.test(s)) { score += 0.15 * (s.match(/\.\.\./g)?.length ?? 0); reasons.push("suspicious ellipses"); }
+  if (/not like|it's not as if|because that always works/i.test(s)) { score += 0.5; reasons.push("classic sarcasm template"); }
+  if (/🙄|😒|😤/u.test(text)) { score += 0.6; reasons.push("betrayed by emoji"); }
+  if (/works on my machine|should be fine|it's just one line|this is fine/i.test(s)) { score += 0.7; reasons.push("infamous phrase detected"); }
+  if (/!{2,}/g.test(s)) { score += 0.2; reasons.push("excessive exclamation"); }
+
+  const confidence = Math.min(1, score);
+  return {
+    sarcastic:  confidence > 0.35,
+    confidence: +confidence.toFixed(2),
+    reason:     reasons.length ? reasons.join(", ") : "vibes",
+  };
+}
+
+// ─── MEETING TITLE GENERATOR ─────────────────────────────────────────────────
+
+const MTG_ADJ   = ["Quick","Brief","Short","Urgent","Important","Mandatory","Optional (but required)","Productive","Effective","Sync","Async","Bi-weekly","Ad-hoc","Recurring","Critical","Strategic","Informational","Time-sensitive","Action-oriented","Stakeholder"];
+const MTG_NOUNS = ["Sync","Check-in","Alignment","Standup","Retrospective","Kickoff","Deep-dive","Brainstorm","Workshop","Discussion","Debrief","Touchbase","Calibration","Review","Readout","Showcase","Planning","Grooming","Estimation","Ceremony"];
+const MTG_TOPIC = ["re: the thing we discussed","(no agenda yet)","TBD","re: Slack thread","follow-up on the follow-up","to discuss the upcoming discussion","re: yesterday's meeting","where we figure out the next meeting","to align on alignment","(details in calendar invite that has no details)"];
+
+/**
+ * Generates a realistic but meaningless meeting invite title.
+ */
+function meetingTitle() {
+  return `${_pick(MTG_ADJ)} ${_pick(MTG_NOUNS)} ${_pick(MTG_TOPIC)}`;
+}
+
+// ─── PASSIVE-AGGRESSIVE EMAIL CLOSER ────────────────────────────────────────
+
+const PA_CLOSERS = [
+  "As per my last email,",
+  "As previously discussed,",
+  "Per our conversation,",
+  "Going forward,",
+  "Just looping in [PERSON] here,",
+  "Not sure if you saw my last message,",
+  "Friendly reminder:",
+  "Circling back on this,",
+  "Bumping this to the top of your inbox,",
+  "Happy to jump on a call if that's easier,",
+  "Let me know if this makes sense,",
+  "Does this work for everyone?",
+  "Thoughts?",
+  "Please advise.",
+  "Let me know your thoughts.",
+  "Hope this helps!",
+  "Does that answer your question?",
+  "Please let me know if you have any questions.",
+  "Thanks in advance.",
+  "Best,",
+];
+
+/**
+ * Returns a passive-aggressive email sign-off or opener.
+ * Use responsibly. Or don't.
+ */
+function paEmail() {
+  return _pick(PA_CLOSERS);
+}
+
+// ─── LOADING MESSAGE GENERATOR ────────────────────────────────────────────────
+
+const LOADING_MSGS = [
+  "Reticulating splines...",
+  "Dividing by zero...",
+  "Spinning up the cloud...",
+  "Contacting the mothership...",
+  "Summoning the daemon...",
+  "Convincing the database to cooperate...",
+  "Asking the compiler nicely...",
+  "Bribing the load balancer...",
+  "Untangling the callback hell...",
+  "Recalibrating the flux capacitor...",
+  "Feeding the hamsters...",
+  "Downloading more RAM...",
+  "Inverting the binary tree...",
+  "Defragmenting the cloud...",
+  "Compiling in the background (lie)...",
+  "Running the tests (also a lie)...",
+  "Warming up the cache...",
+  "Herding the microservices...",
+  "Questioning my career choices...",
+  "Pretending to be busy...",
+  "Generating buzzwords...",
+  "Ignoring the linter...",
+  "Praying to the merge gods...",
+  "Deploying to prod (it's fine)...",
+  "Making it look harder than it is...",
+];
+
+/**
+ * Returns a silly loading message. Useful for delaying the inevitable.
+ * @param {number} count - how many unique messages to return
+ */
+function loadingMessage(count = 1) {
+  const shuffled = [...LOADING_MSGS].sort(() => Math.random() - 0.5);
+  const msgs = shuffled.slice(0, Math.min(count, LOADING_MSGS.length));
+  return count === 1 ? msgs[0] : msgs;
+}
+
+// ─── PROGRAMMER PERSONALITY TYPE ─────────────────────────────────────────────
+
+const PROGRAMMER_TYPES = [
+  { type: "The Tabs Guy",          sign: (s) => /\t/.test(s),                                           desc: "Uses tabs. Will bring it up unprompted." },
+  { type: "The Spaces Person",     sign: (s) => /^  /m.test(s) && !/\t/.test(s),                        desc: "Uses spaces. Also will bring it up unprompted." },
+  { type: "The One-Liner",         sign: (s) => s.split('\n').some(l => l.length > 120),                 desc: "Fits everything in one line. Blames the screen." },
+  { type: "The Comment Avoider",   sign: (s) => !s.includes('//') && !s.includes('/*') && s.length>200, desc: "Code is self-documenting. It isn't." },
+  { type: "The Over-Commenter",    sign: (s) => (s.match(/\/\//g)?.length ?? 0) > 8,                    desc: "Comments every line. Including the closing brace." },
+  { type: "The Magic Number Fan",  sign: (s) => /\b(42|69|1337|9999|999|777)\b/.test(s),                desc: "Numbers have meaning. Just not to anyone else." },
+  { type: "The Ternary Abuser",    sign: (s) => (s.match(/\?/g)?.length ?? 0) > 3,                      desc: "Why use if/else when you can nest ternaries 4 deep?" },
+  { type: "The var Person",        sign: (s) => /\bvar\b/.test(s),                                      desc: "Still using var. ES5 was peak JavaScript." },
+  { type: "The Promise Rejector",  sign: (s) => /\.then\(.*\.then\(.*\.then\(/s.test(s),                desc: "Heard of async/await. Disagrees philosophically." },
+  { type: "The Default Exporter",  sign: () => Math.random() < 0.15,                                    desc: "Everything is default export. Good luck importing it." },
+];
+
+/**
+ * Analyses code and returns the programmer's personality type.
+ * Scientifically dubious.
+ * @param {string} code
+ */
+function programmerType(code) {
+  const matched = PROGRAMMER_TYPES.filter(t => t.sign(String(code)));
+  if (!matched.length) return { type: "The Balanced Developer", desc: "Statistically impossible. Are you okay?" };
+  return _pick(matched);
+}
+
+// ─── SUDO MAKE ME A SANDWICH ─────────────────────────────────────────────────
+
+const SANDWICH_REFUSALS = [
+  "What do you say?",
+  "Please.",
+  "Magic word?",
+  "I don't think so.",
+  "You're not even root on this machine.",
+  "I'm on break.",
+  "Have you tried asking nicely?",
+  "Error 403: sandwich forbidden.",
+  "Not my department.",
+  "Talk to your manager.",
+];
+
+/**
+ * Classic xkcd #149 implementation.
+ * @param {string} input
+ * @returns {string}
+ */
+function sudo(input) {
+  const isSudo = /^sudo\s+/i.test(String(input).trim());
+  const isSandwich = /sandwich/i.test(input);
+  if (isSudo && isSandwich) return "Okay.";
+  if (!isSudo && isSandwich) return _pick(SANDWICH_REFUSALS);
+  if (isSudo) return `sudo: ${input.replace(/^sudo\s+/i,"").split(" ")[0]}: permission denied (just kidding, but no)`;
+  return "sudo: command not found in your heart";
+}
+
+// ─── COMPLIMENT / INSULT GENERATOR ───────────────────────────────────────────
+
+const COMPLIMENT_PARTS = {
+  adj1:   ["elegant","brilliant","surprisingly readable","dare I say clean","almost optimal","boldly structured","hauntingly efficient","suspiciously correct","begrudgingly impressive"],
+  adj2:   ["courageous","time-efficient","dependency-free","side-effect-free","stack-safe","type-safe","merge-conflict-free","lint-passing","test-covering"],
+  noun:   ["approach","implementation","commit","variable name","algorithm","regex","one-liner","abstraction","error message","comment"],
+};
+
+const INSULT_PARTS = {
+  adj1:   ["creative","unique","memorable","ambitious","bold","unconventional","one-of-a-kind","spirited","brave","avant-garde"],
+  adj2:   ["difficult to read","hard to test","impossible to maintain","fun to explain in a postmortem","character-building","a growth opportunity","educational for the team","resume-generating","definitely intentional"],
+  noun:   ["approach","implementation","variable name","architecture decision","regex","abstraction","naming convention","use of globals","comment strategy","deployment strategy"],
+};
+
+/**
+ * Returns a genuine-sounding compliment for someone's code.
+ */
+function codeCompliment() {
+  const p = COMPLIMENT_PARTS;
+  return `This is a genuinely ${_pick(p.adj1)}, ${_pick(p.adj2)} ${_pick(p.noun)}. Well done.`;
+}
+
+/**
+ * Returns a technically-complimentary-but-actually-devastating code critique.
+ */
+function codeInsult() {
+  const p = INSULT_PARTS;
+  return `This is a very ${_pick(p.adj1)} ${_pick(p.noun)}. Very ${_pick(p.adj2)}.`;
+}
+
+// ─── TECHNO-BABBLE GENERATOR ─────────────────────────────────────────────────
+
+const TECHNO_PREFIXES  = ["quantum","neural","blockchain","cloud-native","distributed","asynchronous","recursive","polymorphic","isomorphic","homomorphic","edge-computed","post-quantum","cyber","hyper-converged","event-driven","zero-trust","serverless","AI-powered","ML-augmented","Web3"];
+const TECHNO_MIDDLES   = ["mesh","fabric","lattice","graph","matrix","pipeline","orchestration","federation","consensus","inference","propagation","sharding","topology","namespace","microkernel","hypervisor","sandbox","runtime","middleware","monorepo"];
+const TECHNO_SUFFIXES  = ["as a service","protocol","framework","architecture","paradigm","pattern","abstraction","primitive","contract","oracle","proxy","gateway","resolver","scheduler","allocator","dispatcher","validator","interceptor","serializer","transformer"];
+
+/**
+ * Generates plausible-sounding tech jargon.
+ * Use in pitch decks and funding proposals.
+ * @param {number} count - number of terms
+ */
+function technobabble(count = 1) {
+  const term = () => `${_pick(TECHNO_PREFIXES)} ${_pick(TECHNO_MIDDLES)} ${_pick(TECHNO_SUFFIXES)}`;
+  const terms = Array.from({ length: count }, term);
+  return count === 1 ? terms[0] : terms;
+}
+
+// ─── SILICON VALLEY NAME GENERATOR ────────────────────────────────────────────
+
+const SV_PREFIX = ["Air","Cloud","Snap","Shift","Flux","Spin","Glow","Zip","Dash","Flow","Spark","Bloom","Pulse","Surge","Drift","Hive","Loop","Nest","Nova","Peak","Forge","Kite","Loom","Mint","Orb","Prism","Quill","Ramp","Sage","Trek","Verve","Wove","Xylo","Yoke","Zest"];
+const SV_SUFFIX = ["io","ly","ify","hub","base","kit","lab","pad","bay","box","co","hq","now","up","ful","ai","app","ware","fy","ster"];
+
+/**
+ * Generates a startup name indistinguishable from the real thing.
+ * Incorporates the time-tested science of removing vowels or appending suffixes.
+ * @param {number} count
+ */
+function startupName(count = 1) {
+  const name = () => {
+    const style = Math.random() * 3 | 0;
+    if (style === 0) return _pick(SV_PREFIX) + _pick(SV_SUFFIX);
+    if (style === 1) {
+      const base = _pick(SV_PREFIX).toLowerCase();
+      return (base.replace(/[aeiou]/g, "") + _pick(SV_SUFFIX)).replace(/^./, c => c.toUpperCase());
+    }
+    return _pick(SV_PREFIX) + _pick(SV_PREFIX).toLowerCase() + (_pick(SV_SUFFIX));
+  };
+  const names = Array.from({ length: count }, name);
+  return count === 1 ? names[0] : names;
+}
+
+// ─── DEPENDENCY AUDIT ─────────────────────────────────────────────────────────
+
+/**
+ * Audits a package name and delivers a scathing review.
+ * More accurate than npm audit.
+ * @param {string} packageName
+ */
+function dependencyAudit(packageName) {
+  const pkg    = String(packageName).trim();
+  const scores = {
+    bloat:       Math.random() * 100 | 0,
+    drama:       Math.random() * 100 | 0,  // likelihood of abandoned/drama
+    regret:      Math.random() * 100 | 0,
+    transitive:  2 + (Math.random() * 897 | 0),  // dependencies it pulls in
+  };
+  const verdict = scores.regret > 70
+    ? "You will regret this."
+    : scores.drama > 70
+    ? "The maintainer is currently arguing on GitHub."
+    : scores.bloat > 70
+    ? `This installs ${scores.transitive} packages to do something you could write in 8 lines.`
+    : "Probably fine. Probably.";
+
+  return {
+    package:        pkg,
+    bloatScore:     `${scores.bloat}/100`,
+    dramaScore:     `${scores.drama}/100`,
+    regretScore:    `${scores.regret}/100`,
+    transitiveDeps: scores.transitive,
+    verdict,
+  };
+}
+
+// ─── STANDUP GENERATOR ────────────────────────────────────────────────────────
+
+const STANDUP_YESTERDAY = [
+  "Attended meetings about meetings.",
+  "Fixed the thing I broke while fixing the previous thing.",
+  "Investigated a production incident that turned out to be user error.",
+  "Reviewed a PR that has since been abandoned.",
+  "Wrote a script that already exists in the codebase.",
+  "Updated documentation that nobody reads.",
+  "Refactored something nobody asked me to refactor.",
+  "Spent four hours on a two-line fix.",
+  "Unblocked myself by giving up on the original approach.",
+  "Successfully attended all of my recurring calendar events.",
+];
+const STANDUP_TODAY = [
+  "Continue investigating the investigation.",
+  "Write the PR I've been meaning to write.",
+  "Fix the thing I'll break today.",
+  "Ask for clarification on requirements that will change anyway.",
+  "Attend the meeting about the meeting I attended yesterday.",
+  "Review the PR that broke prod in my absence.",
+  "Sync with stakeholders (unclear which ones).",
+  "Work on the ticket that's been in 'In Progress' for three weeks.",
+  "Close 47 browser tabs from my last debugging session.",
+  "Decide if it's worth bringing up in the retro.",
+];
+const STANDUP_BLOCKERS = [
+  "No blockers (several blockers).",
+  "Waiting on design.",
+  "Waiting on code review.",
+  "Waiting on a response from [NAME] who has been unreachable since Tuesday.",
+  "The ticket is unclear but I'm afraid to ask.",
+  "My local environment.",
+  "A meeting conflict I haven't resolved yet.",
+  "My own earlier decisions.",
+  "Nothing that I'm willing to surface right now.",
+  "The concept of time.",
+];
+
+/**
+ * Generates a realistic-sounding daily standup.
+ */
+function standup() {
+  return {
+    yesterday: _pick(STANDUP_YESTERDAY),
+    today:     _pick(STANDUP_TODAY),
+    blockers:  _pick(STANDUP_BLOCKERS),
+  };
+}
+
+// ─── RETROGRADE EXCUSE ────────────────────────────────────────────────────────
+
+const RETROGRADE_PLANETS = ["Mercury","Venus","Mars","Jupiter","Saturn","Uranus","Neptune","Pluto (still counts)"];
+const RETROGRADE_EFFECTS = [
+  "is causing DNS failures.",
+  "is responsible for your failed deploys.",
+  "explains the race condition.",
+  "is why the tests are flaky.",
+  "is making the CEO ask for a new feature today.",
+  "caused your git push to be rejected.",
+  "is why npm install broke on the CI server.",
+  "explains the merge conflict with yourself.",
+  "is why production is down but staging is fine.",
+  "is responsible for the missing semicolon.",
+];
+
+/**
+ * Blames the current engineering problem on planetary retrograde.
+ * Astrologically certified.
+ */
+function retrogradExcuse() {
+  return `${_pick(RETROGRADE_PLANETS)} in retrograde ${_pick(RETROGRADE_EFFECTS)}`;
+}
+
+// ─── YELL (MOCK SHOUTING) ─────────────────────────────────────────────────────
+
+/**
+ * Converts text to SHOUTING CASE with random extra letters for emphasis.
+ * @param {string} text
+ * @param {number} intensity 0.0–1.0
+ */
+function yell(text, intensity = 0.5) {
+  return String(text)
+    .toUpperCase()
+    .replace(/[A-Z]/g, (ch) =>
+      Math.random() < intensity * 0.3 ? ch.repeat(2 + (Math.random() * 3 | 0)) : ch
+    ) + "!".repeat(1 + (Math.random() * (intensity * 5) | 0));
+}
+
+// ─── TINY STORY GENERATOR ────────────────────────────────────────────────────
+
+const STORY_HERO   = ["a senior engineer","a junior dev","a product manager","the on-call rotation","an intern","a Jira ticket","a rogue cron job","a forgotten Lambda function","the CEO","a rubber duck"];
+const STORY_ACTION = ["accidentally deleted","heroically refactored","mysteriously fixed","desperately tried to understand","fell asleep looking at","wrote unit tests for","blamed DevOps for","opened a ticket about","scheduled a meeting to discuss","gave up on"];
+const STORY_OBJECT = ["the entire production database","a 4,000-line function","the authentication service","a config file with no comments","the company's only backup","a deprecated API endpoint","a regex nobody understands","a global variable named `data`","the last 6 months of logs","the monorepo"];
+const STORY_END    = ["It's fine.","Nobody noticed.","This is in production right now.","The incident report is still open.","They got a promotion anyway.","It worked. We don't know why.","Jira has a ticket for it.","The post-mortem is scheduled for next quarter.","They blamed it on Mercury retrograde.","Same time tomorrow."];
+
+/**
+ * Generates a tiny developer tragedy in three sentences.
+ */
+function tinyStory() {
+  return `${_pick(STORY_HERO)} ${_pick(STORY_ACTION)} ${_pick(STORY_OBJECT)}. ${_pick(STORY_END)} ${_pick(STORY_END)}`;
+}
+
+// ─── IS IT DNS? ────────────────────────────────────────────────────────────────
+
+/**
+ * Determines if the problem is DNS.
+ * It's always DNS.
+ * @param {string} [problem]
+ * @returns {{ isDNS: boolean, confidence: string, explanation: string }}
+ */
+function isItDNS(problem) {
+  const p = String(problem ?? "").toLowerCase();
+  const notDNSWords = ["css","ui","ux","font","color","margin","padding","layout","animation","transition"];
+  const definitelyDNS = notDNSWords.every(w => !p.includes(w));
+  return {
+    isDNS:       true,   // always
+    confidence:  definitelyDNS ? "100%" : "97% (it's still probably DNS)",
+    explanation: definitelyDNS
+      ? "It's DNS. It's always DNS."
+      : "It looked like a CSS problem. It's DNS.",
+  };
+}
+
+// ─── ROCK PAPER SCISSORS ─────────────────────────────────────────────────────
+
+const RPS_BEATS = { rock: "scissors", scissors: "paper", paper: "rock" };
+const RPS_MOVES = Object.keys(RPS_BEATS);
+
+/**
+ * Plays rock-paper-scissors against the computer.
+ * @param {'rock'|'paper'|'scissors'} playerMove
+ * @returns {{ player: string, computer: string, result: 'win'|'lose'|'draw' }}
+ */
+function rps(playerMove) {
+  const p = String(playerMove).toLowerCase();
+  if (!RPS_BEATS[p]) throw new Error(`rps: "${playerMove}" is not a valid move. Try rock, paper, or scissors.`);
+  const computer = _pick(RPS_MOVES);
+  const result   = p === computer ? "draw" : RPS_BEATS[p] === computer ? "win" : "lose";
+  return { player: p, computer, result };
+}
+
+// ─── COIN FLIP ────────────────────────────────────────────────────────────────
+
+/**
+ * Flips a coin. Handles the hard architectural decisions.
+ * @param {number} count
+ */
+function coinFlip(count = 1) {
+  const flips = Array.from({ length: count }, () => Math.random() < 0.5 ? "heads" : "tails");
+  return count === 1 ? flips[0] : { flips, heads: flips.filter(f=>f==="heads").length, tails: flips.filter(f=>f==="tails").length };
+}
+
+// ─── SHOULD I REWRITE IT IN RUST? ────────────────────────────────────────────
+
+const RUST_YES = [
+  "Absolutely. Start today.",
+  "Yes. It's the only way.",
+  "Without question. The memory safety alone justifies it.",
+  "Yes. Attach the migration plan to your next PR.",
+  "The compiler will thank you. Eventually.",
+];
+const RUST_NO = [
+  "No. Ship what you have.",
+  "Not yet. Finish the feature first.",
+  "No. Your team will mutiny.",
+  "No. But think about it for six more months.",
+  "Not unless you enjoy explaining lifetimes to your PM.",
+];
+
+/**
+ * Answers the eternal question.
+ * @returns {{ answer: string, confidence: string }}
+ */
+function shouldRewriteInRust() {
+  const yes = Math.random() > 0.5;
+  return {
+    answer:     _pick(yes ? RUST_YES : RUST_NO),
+    confidence: `${60 + (Math.random() * 39 | 0)}%`,
+  };
+}
+
+// ─── LOREM IPSUM BUT WORSE ────────────────────────────────────────────────────
+
+const DEV_LOREM_CHUNKS = [
+  "undefined is not a function","cannot read property of null","works on my machine","it's a known issue","we can fix it in the next sprint","the ticket is in the backlog","have you tried turning it off and on again","this is just a workaround","the tests were passing locally","we'll add proper error handling later","let's not over-engineer this","this is a temporary solution","the documentation is out of date","we can refactor it after the release","it's not a bug it's a feature","someone else will fix it","we just need to move fast","the build has been failing for two weeks","nobody remembers why this is here","it made sense at the time",
+];
+
+/**
+ * Like lorem ipsum, but for developers.
+ * @param {number} count - number of chunks
+ */
+function devLorem(count = 5) {
+  const chunks = Array.from({ length: count }, () => _pick(DEV_LOREM_CHUNKS));
+  const result = chunks.join(", ") + ".";
+  return result[0].toUpperCase() + result.slice(1);
+}
+
+// ─── THE DAILY WTF ────────────────────────────────────────────────────────────
+
+const WTF_SNIPPETS = [
+  `// I have no idea why this works but don't touch it\nif (typeof x !== 'undefined' && x !== null && !!x && x) { return x; }`,
+  `// TODO: remove this in v2\n// (this comment is from 2019)`,
+  `const TRUE  = false;\nconst FALSE = true; // legacy reasons`,
+  `// This is definitely not a hack\nsetTimeout(() => fixLayout(), 1000);`,
+  `function add(a, b) {\n  // This was faster\n  return a - (-b);\n}`,
+  `if (user.role === 'admin' || user.role === 'admin ') { // don't ask`,
+  `// never null, trust me\nreturn value!;  // TypeScript`,
+  `const data = JSON.parse(JSON.stringify(data)); // deep clone`,
+  `catch (e) { } // the error was annoying`,
+  `// works in prod, breaks in dev\n// works in dev, breaks in prod\nreturn process.env.NODE_ENV === 'production' ? x * 2 : x / 2;`,
+  `for (let i = 0; i < array.length; i++) {\n  i--; i++; // don't remove, fixes off-by-one\n}`,
+  `const isTrue = (val) => val === true || val === 'true' || val === 1 || val === '1' || val === 'yes' || val === 'on';`,
+];
+
+/**
+ * Returns a snippet of code that will haunt you.
+ */
+function dailyWTF() {
+  return _pick(WTF_SNIPPETS);
+}
+
+// ─── EXPORTS ──────────────────────────────────────────────────────────────────
+
+let newFeatures = {
+  buzzword,
+  excuse,
+  commitMessage,
+  badVarName,
+  devHoroscope,
+  enterpriseFunctionName,
+  detectKeyboardSmash,
+  detectSarcasm,
+  meetingTitle,
+  paEmail,
+  loadingMessage,
+  programmerType,
+  sudo,
+  codeCompliment,
+  codeInsult,
+  technobabble,
+  startupName,
+  dependencyAudit,
+  standup,
+  retrogradExcuse,
+  yell,
+  tinyStory,
+  isItDNS,
+  rps,
+  coinFlip,
+  shouldRewriteInRust,
+  devLorem,
+  dailyWTF,
+};
+module.exports = { kitdef: {...kitdef, ...newFeatures} };