perf(basin): cache baseline vacuum across candidates (skill/uma basin)

Profiling a basin (localStorage.torena_perf) showed wall=28s was ~all genuine,
well-parallelized worker compute (14.5x on a 16-pool; main-thread plan-build was
0%). The dominant redundancy: every candidate re-simulates the *baseline* vacuum
(runner without the tracked skill), which is identical across all candidates at a
given sample count — the planner already caches this, the basin pools did not.

Pool workers now memoize the baseline result per run (keyed by seed + sample
count + baseline skill order; reset on init), so the baseline is simulated once
per stage per worker instead of once per skill. Each cached result is read-only
in the reduction, and the key captures the exact (rare) per-candidate sort
variations — so every simulation is byte-identical to before, just not recomputed.

Roughly halves basin worker compute (baseline is ~half the runCompare calls).
typecheck + lint + 221 tests + build + worker guard green.

Author: jalbarrang

src/modules/simulation/simulators/wasm-skill-compare.ts

@@ -213,16 +213,40 @@ class RepresentativeRunTracker {
 }
 
 /** Run a WASM-backed skill comparison for a prebuilt plan entry. Worker-safe. */
+/**
+ * Identity key for a baseline vacuum: every candidate in a basin run shares the
+ * same baseline runner, so its result can be reused instead of re-simulated per
+ * skill. Within a run the only things that vary are the sample count (per stage)
+ * and — rarely — the skill ordering, so the key captures seed + samples + the
+ * baseline skill order. Reused results are read-only in the reduction.
+ */
+function baselineKey(params: WasmCompareParams): string {
+  const skillOrder = (params.runners[0]?.skills ?? [])
+    .map((skill) => skill.skillId)
+    .join(',');
+  return `${params.masterSeed}:${params.nsamples}:${skillOrder}`;
+}
+
+/** Per-run cache of baseline vacuum results, keyed by {@link baselineKey}. */
+export type BaselineCache = Map<string, Promise<WasmCompareData>>;
+
 export async function runSkillComparisonFromEntry(
-  entry: SkillSamplingPlanEntry
+  entry: SkillSamplingPlanEntry,
+  baselineCache?: BaselineCache
 ): Promise<SkillComparisonResult> {
   const { skillId: trackedSkillId, nsamples, fallback, wasmParamsBaseline, wasmParamsTracked } =
     entry;
 
-  const [dataA, dataB] = await Promise.all([
-    runCompare(wasmParamsBaseline),
-    runCompare(wasmParamsTracked)
-  ]);
+  // The baseline (runner without the tracked skill) is identical across every
+  // candidate in the run — run it once and reuse, instead of per skill.
+  const key = baselineKey(wasmParamsBaseline);
+  let baselinePromise = baselineCache?.get(key);
+  if (!baselinePromise) {
+    baselinePromise = runCompare(wasmParamsBaseline);
+    baselineCache?.set(key, baselinePromise);
+  }
+
+  const [dataA, dataB] = await Promise.all([baselinePromise, runCompare(wasmParamsTracked)]);
 
   const diff: Array<number> = [];
   const trackedMetaCollection: Array<SkillTrackedMeta> = [];
@@ -268,13 +292,14 @@ export async function runSkillComparisonFromEntry(
  * `buildSkillSamplingPlan`.
  */
 export async function runSamplingFromPlan(
-  plan: SkillSamplingPlan
+  plan: SkillSamplingPlan,
+  baselineCache?: BaselineCache
 ): Promise<SkillComparisonResponse> {
   const data: SkillComparisonResponse = {};
 
   for (const entry of plan.entries) {
     const { results, runData, min, max, mean, median, skillActivations } =
-      await runSkillComparisonFromEntry(entry);
+      await runSkillComparisonFromEntry(entry, baselineCache);
 
     data[entry.skillId] = {
       id: entry.skillId,

src/workers/pool/skill-basin/skill-basin-wasm.pool.worker.ts

@@ -11,17 +11,22 @@ import type { WorkerInMessage, WorkerOutMessage } from '../types';
 import { initUmaSimWasm, initUmaSimWasmFromModule } from '@/lib/uma-sim-wasm/loader';
 import {
   runSamplingFromPlan,
+  type BaselineCache,
   type SkillSamplingPlan
 } from '@/modules/simulation/simulators/wasm-skill-compare';
 
 let workerId = -1;
+// Baseline vacuum results are identical across candidates; cache them for the
+// lifetime of a run (reset on init) so the baseline is simulated once per stage
+// instead of once per skill.
+let baselineCache: BaselineCache = new Map();
 
 function sendMessage(message: WorkerOutMessage): void {
   postMessage(message);
 }
 
 async function processBatch(batchId: number, plan: SkillSamplingPlan): Promise<void> {
-  const results: SkillComparisonResponse = await runSamplingFromPlan(plan);
+  const results: SkillComparisonResponse = await runSamplingFromPlan(plan, baselineCache);
   sendMessage({ type: 'batch-complete', workerId, batchId, results });
 }
 
@@ -31,6 +36,7 @@ self.addEventListener('message', (event: MessageEvent<WorkerInMessage>) => {
   switch (message.type) {
     case 'init':
       workerId = message.workerId;
+      baselineCache = new Map(); // fresh run — drop any prior baseline results
       (message.compiledModule ? initUmaSimWasmFromModule(message.compiledModule) : initUmaSimWasm())
         .then(() => sendMessage({ type: 'worker-ready', workerId }))
         .catch((error) =>

src/workers/pool/uma-basin/uma-basin-wasm.pool.worker.ts

@@ -11,17 +11,22 @@ import type { WorkerInMessage, WorkerOutMessage } from '../types';
 import { initUmaSimWasm, initUmaSimWasmFromModule } from '@/lib/uma-sim-wasm/loader';
 import {
   runSamplingFromPlan,
+  type BaselineCache,
   type SkillSamplingPlan
 } from '@/modules/simulation/simulators/wasm-skill-compare';
 
 let workerId = -1;
+// Baseline vacuum results are identical across candidates; cache them for the
+// lifetime of a run (reset on init) so the baseline is simulated once per stage
+// instead of once per skill.
+let baselineCache: BaselineCache = new Map();
 
 function sendMessage(message: WorkerOutMessage): void {
   postMessage(message);
 }
 
 async function processBatch(batchId: number, plan: SkillSamplingPlan): Promise<void> {
-  const results: SkillComparisonResponse = await runSamplingFromPlan(plan);
+  const results: SkillComparisonResponse = await runSamplingFromPlan(plan, baselineCache);
   sendMessage({ type: 'batch-complete', workerId, batchId, results });
 }
 
@@ -31,6 +36,7 @@ self.addEventListener('message', (event: MessageEvent<WorkerInMessage>) => {
   switch (message.type) {
     case 'init':
       workerId = message.workerId;
+      baselineCache = new Map(); // fresh run — drop any prior baseline results
       (message.compiledModule ? initUmaSimWasmFromModule(message.compiledModule) : initUmaSimWasm())
         .then(() => sendMessage({ type: 'worker-ready', workerId }))
         .catch((error) =>