claude-petpet 1.0.0 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-petpet",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Find UUIDs that produce specific Claude Code buddy companions",
   "keywords": [
     "buddy",

package/src/cli.ts

@@ -4,12 +4,14 @@
 import * as p from "@clack/prompts";
 
 import { RARITIES, SPECIES, EYES, HATS, STAT_NAMES } from "./enums.ts";
-import { STARS, YIELD_EVERY } from "./consts.ts";
-import { rollFrom, matchesFilters } from "./helpers.ts";
+import { STARS } from "./consts.ts";
+import { rollFromFiltered } from "./helpers.ts";
 import { renderSprite } from "./sprites.ts";
 import { c } from "./color.ts";
 import type { Rarity, StatName, SearchFilters, SearchResult } from "./types.ts";
 
+const WORKER_THRESHOLD = 500_000;
+
 const NONE = "__none__";
 
 async function promptFilters() {
@@ -156,9 +158,7 @@ function formatSummary(filters: SearchFilters): string {
   return parts.join(", ") || "(any)";
 }
 
-async function searchWithProgress(
-  filters: SearchFilters,
-): Promise<{ results: SearchResult[]; searched: number }> {
+async function searchSingleThread(filters: SearchFilters): Promise<{ results: SearchResult[]; searched: number }> {
   const s = p.spinner({ indicator: "timer" });
   s.start("Searching...");
 
@@ -166,15 +166,14 @@ async function searchWithProgress(
   let searched = 0;
 
   for (let i = 0; i < filters.max; i++) {
-    if (i % YIELD_EVERY === 0 && i > 0) {
+    if (i % 50_000 === 0 && i > 0) {
       s.message(`Found ${results.length} match(es), ${i.toLocaleString()} searched`);
       await Bun.sleep(0);
     }
 
     const uuid = crypto.randomUUID();
-    const roll = rollFrom(uuid);
-
-    if (!matchesFilters(roll, filters)) continue;
+    const roll = rollFromFiltered(uuid, filters);
+    if (!roll) continue;
 
     results.push({ ...roll, uuid });
     results.sort((a, b) => b.total - a.total);
@@ -186,10 +185,81 @@ async function searchWithProgress(
 
   searched = searched || filters.max;
   s.stop(`Searched ${searched.toLocaleString()} seeds`);
-
   return { results, searched };
 }
 
+async function searchParallel(filters: SearchFilters): Promise<{ results: SearchResult[]; searched: number }> {
+  const numWorkers = navigator.hardwareConcurrency || 4;
+  const perWorker = Math.ceil(filters.max / numWorkers);
+
+  const s = p.spinner({ indicator: "timer" });
+  s.start(`Searching across ${numWorkers} workers...`);
+
+  const results: SearchResult[] = [];
+  const workerProgress = new Array<number>(numWorkers).fill(0);
+  let totalSearched = 0;
+
+  return new Promise((resolve) => {
+    const workers: Worker[] = [];
+    let doneCount = 0;
+
+    function terminateAll() {
+      for (const w of workers) w.terminate();
+    }
+
+    function finish() {
+      results.sort((a, b) => b.total - a.total);
+      results.length = Math.min(results.length, filters.limit);
+      s.stop(`Searched ${totalSearched.toLocaleString()} seeds across ${numWorkers} workers`);
+      resolve({ results, searched: totalSearched });
+    }
+
+    for (let i = 0; i < numWorkers; i++) {
+      const worker = new Worker(new URL("./worker.ts", import.meta.url));
+      workers.push(worker);
+
+      worker.onmessage = (event) => {
+        const msg = event.data;
+
+        if (msg.type === "match") {
+          results.push(msg.result);
+          // Keep only top N while collecting
+          if (results.length > filters.limit * 2) {
+            results.sort((a, b) => b.total - a.total);
+            results.length = filters.limit;
+          }
+          const searched = workerProgress.reduce((a, b) => a + b, 0);
+          s.message(`Found ${results.length} match(es), ${searched.toLocaleString()} searched`);
+
+          if (results.length >= filters.limit) {
+            totalSearched = searched;
+            terminateAll();
+            finish();
+          }
+        } else if (msg.type === "progress") {
+          workerProgress[i] = msg.searched;
+          const searched = workerProgress.reduce((a, b) => a + b, 0);
+          s.message(`Found ${results.length} match(es), ${searched.toLocaleString()} searched`);
+        } else if (msg.type === "done") {
+          workerProgress[i] = msg.searched;
+          doneCount++;
+          if (doneCount === numWorkers) {
+            totalSearched = workerProgress.reduce((a, b) => a + b, 0);
+            terminateAll();
+            finish();
+          }
+        }
+      };
+
+      worker.postMessage({ filters, count: perWorker });
+    }
+  });
+}
+
+async function searchWithProgress(filters: SearchFilters): Promise<{ results: SearchResult[]; searched: number }> {
+  return filters.max >= WORKER_THRESHOLD ? searchParallel(filters) : searchSingleThread(filters);
+}
+
 function padVisual(s: string, width: number): string {
   return s + " ".repeat(Math.max(0, width - Bun.stringWidth(s)));
 }

package/src/helpers.ts

@@ -73,6 +73,36 @@ export function rollFrom(userId: string): Roll {
   return { rarity, species, eye, hat, shiny, stats, peak, dump, total };
 }
 
+// Like rollFrom, but returns null early when any filter fails.
+// Avoids computing stats/hat/shiny when an earlier property already mismatches.
+export function rollFromFiltered(userId: string, filters: SearchFilters): Roll | null {
+  const rng = mulberry32(hashString(userId + SALT));
+
+  const rarity = rollRarity(rng);
+  if (filters.rarity && rarity !== filters.rarity) return null;
+
+  const species = pick(rng, SPECIES);
+  if (filters.species && species !== filters.species) return null;
+
+  const eye = pick(rng, EYES);
+  if (filters.eye && eye !== filters.eye) return null;
+
+  const hat = rarity === "common" ? "none" : pick(rng, HATS);
+  if (filters.hat && hat !== filters.hat) return null;
+
+  const shiny = rng() < 0.01;
+  if (filters.shiny && !shiny) return null;
+
+  const { stats, peak, dump } = rollStats(rng, rarity);
+  if (filters.peak && peak !== filters.peak) return null;
+  if (filters.dump && dump !== filters.dump) return null;
+
+  const total = Object.values(stats).reduce((a, b) => a + b, 0);
+  if (filters.minTotal && total < filters.minTotal) return null;
+
+  return { rarity, species, eye, hat, shiny, stats, peak, dump, total };
+}
+
 export function matchesFilters(roll: Roll, filters: SearchFilters): boolean {
   if (filters.species && roll.species !== filters.species) return false;
   if (filters.rarity && roll.rarity !== filters.rarity) return false;

package/src/index.ts

@@ -7,6 +7,7 @@ export {
   rollRarity,
   rollStats,
   rollFrom,
+  rollFromFiltered,
   matchesFilters,
   search,
 } from "./helpers.ts";

package/src/worker.ts

@@ -0,0 +1,28 @@
+// Worker script for parallel buddy search.
+
+import { rollFromFiltered } from "./helpers.ts";
+import type { SearchFilters, SearchResult } from "./types.ts";
+
+declare var self: Worker;
+
+const PROGRESS_EVERY = 100_000;
+
+self.onmessage = (event: MessageEvent<{ filters: SearchFilters; count: number }>) => {
+  const { filters, count } = event.data;
+  let searched = 0;
+
+  for (let i = 0; i < count; i++) {
+    if (i % PROGRESS_EVERY === 0 && i > 0) {
+      self.postMessage({ type: "progress", searched: i });
+    }
+
+    const uuid = crypto.randomUUID();
+    const roll = rollFromFiltered(uuid, filters);
+    if (!roll) continue;
+
+    self.postMessage({ type: "match", result: { ...roll, uuid } });
+    searched = i + 1;
+  }
+
+  self.postMessage({ type: "done", searched: searched || count });
+};