buddy-reroll 0.2.0 → 0.3.0

package/lib/companion.js

@@ -0,0 +1,183 @@
+const ORIGINAL_SALT = "friend-2026-401";
+const SALT_LEN = ORIGINAL_SALT.length;
+
+const RARITIES = ["common", "uncommon", "rare", "epic", "legendary"];
+const RARITY_WEIGHTS = { common: 60, uncommon: 25, rare: 10, epic: 4, legendary: 1 };
+const RARITY_TOTAL = Object.values(RARITY_WEIGHTS).reduce((a, b) => a + b, 0);
+const RARITY_FLOOR = { common: 5, uncommon: 15, rare: 25, epic: 35, legendary: 50 };
+
+const SPECIES = [
+  "duck", "goose", "blob", "cat", "dragon", "octopus", "owl", "penguin",
+  "turtle", "snail", "ghost", "axolotl", "capybara", "cactus", "robot",
+  "rabbit", "mushroom", "chonk",
+];
+
+const EYES = ["·", "✦", "×", "◉", "@", "°"];
+const HATS = ["none", "crown", "tophat", "propeller", "halo", "wizard", "beanie", "tinyduck"];
+const STAT_NAMES = ["DEBUGGING", "PATIENCE", "CHAOS", "WISDOM", "SNARK"];
+
+const RARITY_LABELS = {
+  common: "Common (60%)",
+  uncommon: "Uncommon (25%)",
+  rare: "Rare (10%)",
+  epic: "Epic (4%)",
+  legendary: "Legendary (1%)",
+};
+
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a |= 0;
+    a = (a + 0x6d2b79f5) | 0;
+    let t = Math.imul(a ^ (a >>> 15), 1 | a);
+    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+import { wyhash } from "./wyhash.js";
+
+function hashString(value) {
+  if (typeof Bun !== "undefined") return Number(BigInt(Bun.hash(value)) & 0xffffffffn);
+  return Number(wyhash(0n, value) & 0xffffffffn);
+}
+
+function pick(rng, items) {
+  return items[Math.floor(rng() * items.length)];
+}
+
+function rollRarity(rng) {
+  let roll = rng() * RARITY_TOTAL;
+  for (const rarity of RARITIES) {
+    roll -= RARITY_WEIGHTS[rarity];
+    if (roll < 0) return rarity;
+  }
+  return "common";
+}
+
+function rollFrom(salt, userId) {
+  const rng = mulberry32(hashString(userId + salt));
+  const rarity = rollRarity(rng);
+  const species = pick(rng, SPECIES);
+  const eye = pick(rng, EYES);
+  const hat = rarity === "common" ? "none" : pick(rng, HATS);
+  const shiny = rng() < 0.01;
+
+  const floor = RARITY_FLOOR[rarity];
+  const peak = pick(rng, STAT_NAMES);
+  let dump = pick(rng, STAT_NAMES);
+  while (dump === peak) dump = pick(rng, STAT_NAMES);
+
+  const stats = {};
+  for (const name of STAT_NAMES) {
+    if (name === peak) stats[name] = Math.min(100, floor + 50 + Math.floor(rng() * 30));
+    else if (name === dump) stats[name] = Math.max(1, floor - 10 + Math.floor(rng() * 15));
+    else stats[name] = floor + Math.floor(rng() * 40);
+  }
+
+  return { rarity, species, eye, hat, shiny, stats, peak, dump };
+}
+
+function findCurrentSalt(binaryData) {
+  if (binaryData.includes(Buffer.from(ORIGINAL_SALT))) return ORIGINAL_SALT;
+
+  const text = binaryData.toString("latin1");
+
+  const patchedSaltPatterns = [
+    new RegExp(`x{${SALT_LEN - 8}}\\d{8}`, "g"),
+    new RegExp(`friend-\\d{4}-.{${SALT_LEN - 12}}`, "g"),
+  ];
+  for (const pattern of patchedSaltPatterns) {
+    let match = pattern.exec(text);
+    while (match !== null) {
+      if (match[0].length === SALT_LEN) return match[0];
+      match = pattern.exec(text);
+    }
+  }
+
+  const saltRegex = new RegExp(`"([a-zA-Z0-9_-]{${SALT_LEN}})"`, "g");
+  const candidates = new Set();
+  const markers = ["rollRarity", "CompanionBones", "inspirationSeed", "companionUserId"];
+  for (const marker of markers) {
+    const markerIndex = text.indexOf(marker);
+    if (markerIndex === -1) continue;
+
+    const window = text.slice(Math.max(0, markerIndex - 5000), Math.min(text.length, markerIndex + 5000));
+    let match = saltRegex.exec(window);
+    while (match !== null) {
+      candidates.add(match[1]);
+      match = saltRegex.exec(window);
+    }
+  }
+
+  for (const candidate of candidates) {
+    if (/[\d-]/.test(candidate)) return candidate;
+  }
+
+  return null;
+}
+
+function matches(roll, target) {
+  if (target.species && roll.species !== target.species) return false;
+  if (target.rarity && roll.rarity !== target.rarity) return false;
+  if (target.eye && roll.eye !== target.eye) return false;
+  if (target.hat && roll.hat !== target.hat) return false;
+  if (target.shiny !== undefined && roll.shiny !== target.shiny) return false;
+  if (target.peak && roll.peak !== target.peak) return false;
+  if (target.dump && roll.dump !== target.dump) return false;
+  return true;
+}
+
+async function bruteForce(userId, target, onProgress) {
+  const startTime = Date.now();
+  let checked = 0;
+
+  const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_";
+  const suffixLen = SALT_LEN - "friend-2026-".length;
+  if (suffixLen > 0 && suffixLen <= 4) {
+    const generateSuffixes = function* (prefix, depth) {
+      if (depth === 0) {
+        yield prefix;
+        return;
+      }
+      for (const char of chars) yield* generateSuffixes(prefix + char, depth - 1);
+    };
+
+    for (const suffix of generateSuffixes("", suffixLen)) {
+      const salt = `friend-2026-${suffix}`;
+      checked++;
+      const result = rollFrom(salt, userId);
+      if (matches(result, target)) return { salt, result, checked, elapsed: Date.now() - startTime };
+    }
+  }
+
+  for (let index = 0; index < 1_000_000_000; index++) {
+    const salt = String(index).padStart(SALT_LEN, "x");
+    checked++;
+    const result = rollFrom(salt, userId);
+    if (matches(result, target)) return { salt, result, checked, elapsed: Date.now() - startTime };
+
+    if (checked % 100_000 === 0) {
+      await new Promise((resolve) => setTimeout(resolve, 0));
+    }
+    if (checked % 5_000_000 === 0 && onProgress) {
+      onProgress(checked, Date.now() - startTime);
+    }
+  }
+
+  return null;
+}
+
+export {
+  EYES,
+  HATS,
+  RARITIES,
+  RARITY_LABELS,
+  RARITY_WEIGHTS,
+  SPECIES,
+  STAT_NAMES,
+  bruteForce,
+  findCurrentSalt,
+  matches,
+  rollFrom,
+};

package/lib/companion.test.js

@@ -0,0 +1,134 @@
+import { describe, it, expect } from "bun:test";
+import { rollFrom, matches, findCurrentSalt } from "./companion.js";
+
+describe("rollFrom", () => {
+  it("returns deterministic result for same salt + userId", () => {
+    const a = rollFrom("friend-2026-401", "test-user");
+    const b = rollFrom("friend-2026-401", "test-user");
+    expect(a).toEqual(b);
+  });
+
+  it("returns different results for different salts", () => {
+    const a = rollFrom("friend-2026-401", "test-user");
+    const b = rollFrom("friend-2026-402", "test-user");
+    expect(a.species === b.species && a.rarity === b.rarity && a.eye === b.eye).toBe(false);
+  });
+
+  it("returns all required fields", () => {
+    const result = rollFrom("friend-2026-401", "test-user");
+    expect(result).toHaveProperty("rarity");
+    expect(result).toHaveProperty("species");
+    expect(result).toHaveProperty("eye");
+    expect(result).toHaveProperty("hat");
+    expect(result).toHaveProperty("shiny");
+    expect(result).toHaveProperty("stats");
+  });
+
+  it("returns valid rarity", () => {
+    const validRarities = ["common", "uncommon", "rare", "epic", "legendary"];
+    const result = rollFrom("friend-2026-401", "test-user");
+    expect(validRarities).toContain(result.rarity);
+  });
+
+  it("common rarity always has hat=none", () => {
+    let found = false;
+    for (let i = 0; i < 1000 && !found; i++) {
+      const salt = String(i).padStart(15, "x");
+      const result = rollFrom(salt, "test-user");
+      if (result.rarity === "common") {
+        expect(result.hat).toBe("none");
+        found = true;
+      }
+    }
+    expect(found).toBe(true);
+  });
+
+  it("stats values are within valid range (1-100)", () => {
+    const result = rollFrom("friend-2026-401", "test-user");
+    for (const value of Object.values(result.stats)) {
+      expect(value).toBeGreaterThanOrEqual(1);
+      expect(value).toBeLessThanOrEqual(100);
+    }
+  });
+});
+
+describe("matches", () => {
+  const roll = { species: "duck", rarity: "common", eye: "·", hat: "none", shiny: false };
+
+  it("matches when target is empty", () => {
+    expect(matches(roll, {})).toBe(true);
+  });
+
+  it("matches exact species", () => {
+    expect(matches(roll, { species: "duck" })).toBe(true);
+    expect(matches(roll, { species: "cat" })).toBe(false);
+  });
+
+  it("matches partial target", () => {
+    expect(matches(roll, { species: "duck", rarity: "common" })).toBe(true);
+    expect(matches(roll, { species: "duck", rarity: "rare" })).toBe(false);
+  });
+
+  it("matches shiny flag", () => {
+    expect(matches(roll, { shiny: false })).toBe(true);
+    expect(matches(roll, { shiny: true })).toBe(false);
+  });
+
+  it("ignores undefined shiny in target", () => {
+    expect(matches(roll, { species: "duck", shiny: undefined })).toBe(true);
+  });
+
+  it("matches peak stat", () => {
+    const rollWithStats = rollFrom("friend-2026-401", "test-user");
+    expect(matches(rollWithStats, { peak: rollWithStats.peak })).toBe(true);
+    const otherStats = ["DEBUGGING", "PATIENCE", "CHAOS", "WISDOM", "SNARK"].filter(s => s !== rollWithStats.peak);
+    expect(matches(rollWithStats, { peak: otherStats[0] })).toBe(false);
+  });
+
+  it("matches dump stat", () => {
+    const rollWithStats = rollFrom("friend-2026-401", "test-user");
+    expect(matches(rollWithStats, { dump: rollWithStats.dump })).toBe(true);
+    const otherStats = ["DEBUGGING", "PATIENCE", "CHAOS", "WISDOM", "SNARK"].filter(s => s !== rollWithStats.dump);
+    expect(matches(rollWithStats, { dump: otherStats[0] })).toBe(false);
+  });
+
+  it("ignores peak/dump when not in target", () => {
+    const rollWithStats = rollFrom("friend-2026-401", "test-user");
+    expect(matches(rollWithStats, { species: rollWithStats.species })).toBe(true);
+  });
+});
+
+describe("rollFrom peak/dump fields", () => {
+  it("returns peak and dump stat names", () => {
+    const result = rollFrom("friend-2026-401", "test-user");
+    const validStats = ["DEBUGGING", "PATIENCE", "CHAOS", "WISDOM", "SNARK"];
+    expect(validStats).toContain(result.peak);
+    expect(validStats).toContain(result.dump);
+    expect(result.peak).not.toBe(result.dump);
+  });
+
+  it("peak stat has highest value, dump has lowest", () => {
+    const result = rollFrom("friend-2026-401", "test-user");
+    expect(result.stats[result.peak]).toBeGreaterThanOrEqual(result.stats[result.dump]);
+  });
+});
+
+describe("findCurrentSalt", () => {
+  const ORIGINAL_SALT = "friend-2026-401";
+
+  it("finds original salt in binary data", () => {
+    const data = Buffer.from(`some binary data ${ORIGINAL_SALT} more data`);
+    expect(findCurrentSalt(data)).toBe(ORIGINAL_SALT);
+  });
+
+  it("finds patched salt (numeric pattern)", () => {
+    const patchedSalt = "xxxxxxx00000001";
+    const data = Buffer.from(`some binary data "${patchedSalt}" rollRarity more data`);
+    expect(findCurrentSalt(data)).toBe(patchedSalt);
+  });
+
+  it("returns null when no salt found", () => {
+    const data = Buffer.from("no salt here at all");
+    expect(findCurrentSalt(data)).toBeNull();
+  });
+});

package/lib/doctor.js

@@ -0,0 +1,73 @@
+import { getClaudeBinaryOverride, getClaudeConfigDir, findBinaryPath, findConfigPath, getPatchability } from "./runtime.js";
+
+function buildStatus(binaryPath, configPath, patchability) {
+  if (!binaryPath && !configPath) return "missing-binary-and-config";
+  if (!binaryPath) return "missing-binary";
+  if (!configPath) return "missing-config";
+  if (!patchability.ok) return "read-only";
+  return "ready";
+}
+
+function buildNextStep(status) {
+  switch (status) {
+    case "missing-binary-and-config":
+      return "Install Claude Code, make sure `claude` is discoverable on PATH, or set `CLAUDE_BINARY_PATH` and `CLAUDE_CONFIG_DIR`.";
+    case "missing-binary":
+      return "Make sure `claude` is discoverable on PATH or set `CLAUDE_BINARY_PATH` to the real Claude executable.";
+    case "missing-config":
+      return "Open Claude Code once so it writes config, or point `CLAUDE_CONFIG_DIR` to the correct config directory.";
+    case "read-only":
+      return "Use a user-writable Claude install, or point `CLAUDE_BINARY_PATH` to a writable Claude binary copy; `--current` can still work with a read-only install.";
+    default:
+      return "`--current` and reroll commands are ready to run on this machine.";
+  }
+}
+
+export function getDoctorReport() {
+  const binaryOverride = getClaudeBinaryOverride();
+  const configDir = getClaudeConfigDir();
+  const binaryPath = findBinaryPath();
+  const configPath = findConfigPath();
+  const patchability = binaryPath
+    ? getPatchability(binaryPath)
+    : { ok: false, message: "Claude Code binary path is missing.", backupPath: null };
+  const status = buildStatus(binaryPath, configPath, patchability);
+
+  return {
+    status,
+    binaryOverride,
+    configDir,
+    binaryPath,
+    configPath,
+    patchability,
+    canRunCurrent: Boolean(binaryPath && configPath),
+    nextStep: buildNextStep(status),
+  };
+}
+
+export function formatDoctorReport(report, title = "Doctor report") {
+  const lines = [
+    title,
+    `  Status:          ${report.status}`,
+    `  Binary override: ${report.binaryOverride ?? "not set"}`,
+    `  Config dir:      ${report.configDir}`,
+    `  Binary path:     ${report.binaryPath ?? "not found"}`,
+    `  Config path:     ${report.configPath ?? "not found"}`,
+    `  Read current:    ${report.canRunCurrent ? "yes" : "no"}`,
+  ];
+
+  if (report.binaryPath) {
+    lines.push(`  Patchability:    ${report.patchability.ok ? "writable" : "read-only"}`);
+    lines.push(`  Backup path:     ${report.patchability.backupPath ?? "not available"}`);
+  } else {
+    lines.push("  Patchability:    not available");
+    lines.push("  Backup path:     not available");
+  }
+
+  if (!report.patchability.ok && report.patchability.message) {
+    lines.push(`  Note:            ${report.patchability.message}`);
+  }
+
+  lines.push(`  Next step:       ${report.nextStep}`);
+  return lines.join("\n");
+}

package/lib/estimator.js

@@ -0,0 +1,43 @@
+import { RARITY_WEIGHTS } from "./companion.js";
+
+export function estimateAttempts(target) {
+  if (!target || Object.keys(target).length === 0) return 1;
+
+  let probability = 1;
+
+  if (target.species) probability *= 1 / 18;
+  if (target.rarity) probability *= RARITY_WEIGHTS[target.rarity] / 100;
+  if (target.eye) probability *= 1 / 6;
+  if (target.hat && target.rarity !== "common") probability *= 1 / 8;
+  if (target.shiny === true) probability *= 0.01;
+  if (target.peak) probability *= 1 / 5;
+  if (target.dump) probability *= 1 / 4;
+
+  return Math.round(1 / probability);
+}
+
+export function formatProgress(attempts, elapsed, expected, workers) {
+  const pct = Math.min(100, Math.round((attempts / expected) * 100));
+  const rate = attempts / (elapsed / 1000);
+
+  let rateStr;
+  if (rate >= 1_000_000) {
+    rateStr = (rate / 1_000_000).toFixed(1) + "M tries/s";
+  } else if (rate >= 1_000) {
+    rateStr = (rate / 1_000).toFixed(1) + "k tries/s";
+  } else {
+    rateStr = rate.toFixed(1) + " tries/s";
+  }
+
+  const remaining = Math.max(0, (expected - attempts) / rate);
+  let etaStr;
+  if (remaining < 60) {
+    etaStr = Math.round(remaining) + "s";
+  } else {
+    const minutes = Math.floor(remaining / 60);
+    const seconds = Math.round(remaining % 60);
+    etaStr = minutes + "m " + seconds + "s";
+  }
+
+  return `${pct}% | ${rateStr} | ~${etaStr} left | ${workers} cores`;
+}

package/lib/estimator.test.js

@@ -0,0 +1,97 @@
+import { describe, it, expect } from "bun:test";
+import { estimateAttempts, formatProgress } from "./estimator.js";
+
+describe("estimateAttempts", () => {
+  it("returns 1 for empty target", () => {
+    expect(estimateAttempts({})).toBe(1);
+  });
+
+  it("returns 18 for species only", () => {
+    expect(estimateAttempts({ species: "duck" })).toBe(18);
+  });
+
+  it("returns 30 for species + common rarity", () => {
+    expect(estimateAttempts({ species: "duck", rarity: "common" })).toBe(30);
+  });
+
+  it("returns 1800 for species + legendary rarity", () => {
+    expect(estimateAttempts({ species: "duck", rarity: "legendary" })).toBe(1800);
+  });
+
+  it("returns 180 for species + rarity + eye", () => {
+    expect(estimateAttempts({ species: "duck", rarity: "common", eye: "·" })).toBe(180);
+  });
+
+  it("returns 3456 for species + rarity + eye + hat (non-common)", () => {
+    expect(estimateAttempts({ species: "duck", rarity: "uncommon", eye: "·", hat: "crown" })).toBe(3456);
+  });
+
+  it("returns 1800 for shiny only", () => {
+    expect(estimateAttempts({ shiny: true })).toBe(100);
+  });
+
+  it("returns 5 for peak only", () => {
+    expect(estimateAttempts({ peak: "DEBUGGING" })).toBe(5);
+  });
+
+  it("returns 4 for dump only", () => {
+    expect(estimateAttempts({ dump: "DEBUGGING" })).toBe(4);
+  });
+
+  it("returns large number for full combo", () => {
+    const result = estimateAttempts({
+      species: "dragon",
+      rarity: "legendary",
+      eye: "✦",
+      hat: "propeller",
+      shiny: true,
+      peak: "WISDOM",
+      dump: "SNARK",
+    });
+    expect(result).toBeGreaterThan(1_000_000);
+  });
+
+  it("does not multiply by hat for common rarity", () => {
+    const withoutHat = estimateAttempts({ species: "duck", rarity: "common" });
+    const withHat = estimateAttempts({ species: "duck", rarity: "common", hat: "none" });
+    expect(withoutHat).toBe(withHat);
+  });
+});
+
+describe("formatProgress", () => {
+  it("formats progress with millions of salts per second", () => {
+    const result = formatProgress(5_000_000, 2000, 10_000_000, 8);
+    expect(result).toContain("50%");
+    expect(result).toContain("2.5M tries/s");
+    expect(result).toContain("8 cores");
+  });
+
+  it("formats progress with thousands of salts per second", () => {
+    const result = formatProgress(50_000, 5000, 100_000, 4);
+    expect(result).toContain("50%");
+    expect(result).toContain("10.0k tries/s");
+    expect(result).toContain("4 cores");
+  });
+
+  it("formats ETA in seconds", () => {
+    const result = formatProgress(9_000_000, 1000, 10_000_000, 8);
+    expect(result).toContain("left");
+    expect(result).toContain("s");
+  });
+
+  it("formats ETA in minutes and seconds", () => {
+    const result = formatProgress(1_000_000, 1000, 100_000_000, 8);
+    expect(result).toContain("m");
+  });
+
+  it("caps percentage at 100", () => {
+    const result = formatProgress(10_000_000, 1000, 10_000_000, 8);
+    expect(result).toContain("100%");
+  });
+
+  it("handles zero elapsed time gracefully", () => {
+    const result = formatProgress(1_000_000, 1, 10_000_000, 8);
+    expect(result).toContain("%");
+    expect(result).toContain("tries/s");
+  });
+});

package/lib/finder.js

@@ -0,0 +1,104 @@
+import { spawn } from "child_process";
+import { cpus } from "os";
+import { fileURLToPath } from "url";
+import { join, dirname } from "path";
+import { estimateAttempts } from "./estimator.js";
+import { rollFrom } from "./companion.js";
+
+const WORKER_SCRIPT = join(dirname(fileURLToPath(import.meta.url)), "..", "scripts", "worker.js");
+
+export async function parallelBruteForce(userId, target, onProgress) {
+  const numWorkers = Math.max(1, Math.min(cpus().length, 8));
+  const expected = estimateAttempts(target);
+
+  return new Promise((resolve, reject) => {
+    const children = [];
+    const workerStdout = [];
+    const workerAttempts = [];
+    let resolved = false;
+    let exited = 0;
+
+    function killAll() {
+      for (const child of children) {
+        try { child.kill(); } catch {}
+      }
+    }
+
+    for (let i = 0; i < numWorkers; i++) {
+      workerStdout[i] = "";
+      workerAttempts[i] = 0;
+
+      const child = spawn(process.execPath, [WORKER_SCRIPT, userId, JSON.stringify(target)], {
+        stdio: ["ignore", "pipe", "pipe"],
+      });
+      children.push(child);
+
+      child.stdout.on("data", (chunk) => {
+        workerStdout[i] += chunk.toString();
+      });
+
+      child.stderr.on("data", (chunk) => {
+        const lines = chunk.toString().split("\n").filter(Boolean);
+        for (const line of lines) {
+          try {
+            const progress = JSON.parse(line);
+            if (progress.attempts) {
+              workerAttempts[i] = progress.attempts;
+              const totalAttempts = workerAttempts.reduce((a, b) => a + b, 0);
+              const elapsed = progress.elapsed || 0;
+              if (onProgress) {
+                onProgress(totalAttempts, elapsed, expected, numWorkers);
+              }
+            }
+          } catch {}
+        }
+      });
+
+      child.on("close", (code) => {
+        exited++;
+        if (resolved) return;
+
+        if (code === 0 && workerStdout[i].trim()) {
+          resolved = true;
+          killAll();
+
+          try {
+            const result = JSON.parse(workerStdout[i].trim());
+            const totalAttempts = workerAttempts.reduce((a, b) => a + b, 0);
+            const roll = rollFrom(result.salt, userId);
+            resolve({
+              salt: result.salt,
+              result: roll,
+              checked: Math.max(totalAttempts, result.attempts),
+              elapsed: result.elapsed,
+              workers: numWorkers,
+            });
+          } catch (err) {
+            reject(err);
+          }
+          return;
+        }
+
+        if (exited === numWorkers && !resolved) {
+          resolve(null);
+        }
+      });
+
+      child.on("error", () => {
+        exited++;
+        if (exited === numWorkers && !resolved) {
+          resolve(null);
+        }
+      });
+    }
+
+    const timeoutMs = Math.max(600_000, Math.ceil(expected / 50_000_000) * 60_000 + 600_000);
+    setTimeout(() => {
+      if (!resolved) {
+        resolved = true;
+        killAll();
+        resolve(null);
+      }
+    }, timeoutMs);
+  });
+}

package/lib/finder.test.js

@@ -0,0 +1,35 @@
+import { describe, it, expect } from "bun:test";
+import { parallelBruteForce } from "./finder.js";
+
+describe("parallelBruteForce", () => {
+  it("finds matching salt for simple target", async () => {
+    const result = await parallelBruteForce("test-user", { species: "duck" }, null);
+    expect(result).not.toBeNull();
+    expect(result.salt).toBeDefined();
+    expect(result.result.species).toBe("duck");
+    expect(result.checked).toBeGreaterThan(0);
+    expect(result.elapsed).toBeGreaterThanOrEqual(0);
+    expect(result.workers).toBeGreaterThanOrEqual(1);
+  }, 30_000);
+
+  it("calls onProgress callback", async () => {
+    let progressCalled = false;
+    await parallelBruteForce("test-user", { species: "cat" }, (attempts, elapsed, expected, workers) => {
+      if (attempts > 0) progressCalled = true;
+    });
+  }, 30_000);
+
+  it("returns result with compatible shape", async () => {
+    const result = await parallelBruteForce("test-user", { species: "blob" }, null);
+    expect(result).toHaveProperty("salt");
+    expect(result).toHaveProperty("result");
+    expect(result).toHaveProperty("checked");
+    expect(result).toHaveProperty("elapsed");
+    expect(result.result).toHaveProperty("rarity");
+    expect(result.result).toHaveProperty("species");
+    expect(result.result).toHaveProperty("eye");
+    expect(result.result).toHaveProperty("hat");
+    expect(result.result).toHaveProperty("shiny");
+    expect(result.result).toHaveProperty("stats");
+  }, 30_000);
+});