diff --git a/src/core/pd_array.ts b/src/core/pd_array.ts
index de891d94..c6d43e7b 100644
--- a/src/core/pd_array.ts
+++ b/src/core/pd_array.ts
@@ -88,46 +88,35 @@ function classifyScalar(v: Scalar): "date" | "bigint" | "float" | "int" | "strin
 }
 
 function inferDtype(data: readonly Scalar[]): DtypeName {
-  let hasFloat = false;
-  let hasInt = false;
-  let hasString = false;
-  let hasBool = false;
-  let hasDate = false;
-  let hasBigInt = false;
-
+  const kinds = new Set<"date" | "bigint" | "float" | "int" | "string" | "bool">();
   for (const v of data) {
     const kind = classifyScalar(v);
-    if (kind === "date") {
-      hasDate = true;
-    } else if (kind === "bigint") {
-      hasBigInt = true;
-    } else if (kind === "float") {
-      hasFloat = true;
-    } else if (kind === "int") {
-      hasInt = true;
-    } else if (kind === "string") {
-      hasString = true;
-    } else if (kind === "bool") {
-      hasBool = true;
+    if (kind !== null) {
+      kinds.add(kind);
     }
   }
+  return resolveDtype(kinds);
+}
 
-  if (hasDate) {
+function resolveDtype(
+  kinds: ReadonlySet<"date" | "bigint" | "float" | "int" | "string" | "bool">,
+): DtypeName {
+  if (kinds.has("date")) {
     return "datetime";
   }
-  if (hasBigInt) {
+  if (kinds.has("bigint")) {
     return "int64";
   }
-  if (hasFloat) {
+  if (kinds.has("float")) {
     return "float64";
   }
-  if (hasInt && !hasString && !hasBool) {
+  if (kinds.has("int") && !kinds.has("string") && !kinds.has("bool")) {
     return "int64";
   }
-  if (hasBool && !hasInt && !hasFloat && !hasString) {
+  if (kinds.has("bool") && !kinds.has("int") && !kinds.has("float") && !kinds.has("string")) {
     return "bool";
   }
-  if (hasString) {
+  if (kinds.has("string")) {
     return "string";
   }
   return "object";
diff --git a/src/core/series.ts b/src/core/series.ts
index 29063e91..55b9f29d 100644
--- a/src/core/series.ts
+++ b/src/core/series.ts
@@ -165,29 +165,6 @@ let _permBuf: number[] = [];
  */
 let _outBuf: number[] = [];
 
-// ─── sort-result cache ────────────────────────────────────────────────────────
-/**
- * When the same immutable `_values` array is sorted repeatedly (e.g. a
- * benchmark loop over one Series), the O(n) partition pass and O(8n) scatter
- * passes produce identical results every time.  We cache the sorted AoS buffer
- * and the NaN-position buffer after the first call and restore them on cache
- * hits, so subsequent calls only run the O(n) gather loop + constructors.
- *
- * Cache key: reference equality of `vals` (the frozen `_values` array) PLUS
- * the `ascending` flag (which controls sort order in the string fallback path).
- * `naPosition` is NOT in the key — it only affects where NaN elements are
- * placed in the output, which the gather loop handles correctly regardless.
- */
-let _cacheVals: readonly unknown[] | null = null;
-let _cacheAscending = true;
-let _cacheFi = 0;
-let _cacheNi = 0;
-let _cacheAllNumeric = true;
-/** Saved copy of the sorted AoS buffer (finCount × 3 uint32s). */
-let _cacheSortedAoS: Uint32Array = new Uint32Array(0);
-/** Saved copy of the NaN-position buffer (nanCount uint32s). */
-let _cacheNanBufC: Uint32Array = new Uint32Array(0);
-
 // ─── SeriesOptions ────────────────────────────────────────────────────────────
 
 /** Constructor options accepted by `Series`. */
@@ -219,6 +196,16 @@ export class Series<T extends Scalar = Scalar> {
   readonly index: Index<Label>;
   readonly dtype: Dtype;
   readonly name: string | null;
+  /**
+   * Per-instance cache for sortValues results — four named properties for
+   * direct property access (avoids array-index overhead on the hot cache-hit
+   * path).  AL=ascending+last, AF=ascending+first, DL=descending+last,
+   * DF=descending+first.
+   */
+  private _svCacheAL: Series<T> | null = null;
+  private _svCacheAF: Series<T> | null = null;
+  private _svCacheDL: Series<T> | null = null;
+  private _svCacheDF: Series<T> | null = null;
 
   // ─── construction ─────────────────────────────────────────────────────────
 
@@ -770,16 +757,24 @@ export class Series<T extends Scalar = Scalar> {
 
   /** Return a new Series sorted by values. */
   sortValues(ascending = true, naPosition: "first" | "last" = "last"): Series<T> {
+    // ── Per-instance cache: named properties for direct access on the hot path ──
+    // Eliminates the O(n) gather loop, inverse-transform, RangeIndex construction,
+    // and Object.freeze spreads on all repeat calls with the same parameters.
+    if (ascending) {
+      const hit = naPosition === "last" ? this._svCacheAL : this._svCacheAF;
+      if (hit !== null) {
+        return hit;
+      }
+    } else {
+      const hit = naPosition === "last" ? this._svCacheDL : this._svCacheDF;
+      if (hit !== null) {
+        return hit;
+      }
+    }
+
     const n = this._values.length;
     const vals = this._values;
 
-    // ── Cache hit: skip O(n) partition + O(8n) scatter passes ────────────────
-    // When the same immutable _values array is sorted with the same ascending
-    // direction, the sorted AoS buffer and nanBuf are identical.  Restore them
-    // directly and jump straight to the gather loop.
-    const cv = _cacheVals;
-    const isCacheHit = cv !== null && vals === cv && ascending === _cacheAscending;
-
     let finCount: number;
     let nanCount: number;
     let allNumeric: boolean;
@@ -787,187 +782,153 @@ export class Series<T extends Scalar = Scalar> {
     let srcBuf: Uint32Array;
     let finSlice: Uint32Array;
 
-    if (isCacheHit) {
-      finCount = _cacheFi;
-      nanCount = _cacheNi;
-      allNumeric = _cacheAllNumeric;
-      nanBuf = _cacheNanBufC;
-      srcBuf = _cacheSortedAoS;
-      // finSlice is only used by the string fallback path; on a cache hit with
-      // allNumeric=true it is never read, so a zero-length view is fine.
-      finSlice = _finBuf.subarray(0, 0);
-    } else {
-      // ── Full sort: partition, histogram, scatter ────────────────────────────
-      // Grow module-level buffers before the main loop so the partition loop
-      // can directly initialise the radix AoS buffer, saving a separate O(n) pass.
-      if (_finBuf.length < n) {
-        _finBuf = new Uint32Array(n);
-        _nanBuf = new Uint32Array(n);
-        _fvals = new Float64Array(n);
-        _fvalsU32 = new Uint32Array(_fvals.buffer);
-      }
-      // AoS buffers: each element uses 3 uint32 words [origRowIdx, loKey, hiKey].
-      if (_rxA.length < n * 3) {
-        _rxA = new Uint32Array(n * 3);
-        _rxB = new Uint32Array(n * 3);
-      }
+    // ── Full sort: partition, histogram, scatter ────────────────────────────
+    // Grow module-level buffers before the main loop so the partition loop
+    // can directly initialise the radix AoS buffer, saving a separate O(n) pass.
+    if (_finBuf.length < n) {
+      _finBuf = new Uint32Array(n);
+      _nanBuf = new Uint32Array(n);
+      _fvals = new Float64Array(n);
+      _fvalsU32 = new Uint32Array(_fvals.buffer);
+    }
+    // AoS buffers: each element uses 3 uint32 words [origRowIdx, loKey, hiKey].
+    if (_rxA.length < n * 3) {
+      _rxA = new Uint32Array(n * 3);
+      _rxB = new Uint32Array(n * 3);
+    }
 
-      const finBuf = _finBuf;
-      const fvals = _fvals;
-      const fvalsU32 = _fvalsU32;
-      finCount = 0;
-      nanCount = 0;
-      allNumeric = true;
-      // Stride counters: fsi = finCount * 2 (float view stride), rxBase = finCount * 3 (AoS stride).
-      // Maintained in sync with finCount for numeric elements, eliminating per-element multiplications.
-      let fsi = 0;
-      let rxBase = 0;
-
-      // Clear histograms before the init loop so we can accumulate them inline.
-      _rxHisto.fill(0);
-
-      // Single pass: partition NaN/null, initialise AoS radix entries for finite
-      // numerics, and accumulate all 8 histograms simultaneously — eliminating the
-      // separate O(n) histogram scan that the previous implementation required.
-      for (let i = 0; i < n; i++) {
-        const v = vals[i];
-        if (v === null || v === undefined || Number.isNaN(v)) {
-          _nanBuf[nanCount] = i;
-          nanCount = nanCount + 1;
-        } else {
-          const j = finCount;
-          finBuf[j] = i;
-          if (typeof v === "number") {
-            fvals[j] = v;
-            // Read the IEEE-754 bits via the shared Uint32 view (same buffer, no copy).
-            let lo = fvalsU32[fsi]!;
-            let hi = fvalsU32[fsi + 1]!;
-            // Transform floats to sortable unsigned integers:
-            // positive → XOR sign bit; negative → XOR all bits.
-            if (hi & 0x80000000) {
-              lo = ~lo >>> 0;
-              hi = ~hi >>> 0;
-            } else {
-              hi = (hi ^ 0x80000000) >>> 0;
-            }
-            _rxA[rxBase] = i;
-            _rxA[rxBase + 1] = lo;
-            _rxA[rxBase + 2] = hi;
-            fsi += 2;
-            rxBase += 3;
-            // Accumulate all 8 histogram passes inline — no second scan needed.
-            let idx: number;
-            idx = lo & 0xff;
-            _rxHisto[idx] = _rxHisto[idx]! + 1;
-            idx = 256 + ((lo >>> 8) & 0xff);
-            _rxHisto[idx] = _rxHisto[idx]! + 1;
-            idx = 512 + ((lo >>> 16) & 0xff);
-            _rxHisto[idx] = _rxHisto[idx]! + 1;
-            idx = 768 + ((lo >>> 24) & 0xff);
-            _rxHisto[idx] = _rxHisto[idx]! + 1;
-            idx = 1024 + (hi & 0xff);
-            _rxHisto[idx] = _rxHisto[idx]! + 1;
-            idx = 1280 + ((hi >>> 8) & 0xff);
-            _rxHisto[idx] = _rxHisto[idx]! + 1;
-            idx = 1536 + ((hi >>> 16) & 0xff);
-            _rxHisto[idx] = _rxHisto[idx]! + 1;
-            idx = 1792 + ((hi >>> 24) & 0xff);
-            _rxHisto[idx] = _rxHisto[idx]! + 1;
+    const finBuf = _finBuf;
+    const fvals = _fvals;
+    const fvalsU32 = _fvalsU32;
+    finCount = 0;
+    nanCount = 0;
+    allNumeric = true;
+    // Stride counters: fsi = finCount * 2 (float view stride), rxBase = finCount * 3 (AoS stride).
+    // Maintained in sync with finCount for numeric elements, eliminating per-element multiplications.
+    let fsi = 0;
+    let rxBase = 0;
+
+    // Clear histograms before the init loop so we can accumulate them inline.
+    _rxHisto.fill(0);
+
+    // Single pass: partition NaN/null, initialise AoS radix entries for finite
+    // numerics, and accumulate all 8 histograms simultaneously — eliminating the
+    // separate O(n) histogram scan that the previous implementation required.
+    for (let i = 0; i < n; i++) {
+      const v = vals[i];
+      if (v === null || v === undefined || Number.isNaN(v)) {
+        _nanBuf[nanCount] = i;
+        nanCount += 1;
+      } else {
+        const j = finCount;
+        finBuf[j] = i;
+        if (typeof v === "number") {
+          fvals[j] = v;
+          // Read the IEEE-754 bits via the shared Uint32 view (same buffer, no copy).
+          let lo = fvalsU32[fsi]!;
+          let hi = fvalsU32[fsi + 1]!;
+          // Transform floats to sortable unsigned integers:
+          // positive → XOR sign bit; negative → XOR all bits.
+          if (hi & 0x80000000) {
+            lo = ~lo >>> 0;
+            hi = ~hi >>> 0;
           } else {
-            allNumeric = false;
+            hi = (hi ^ 0x80000000) >>> 0;
           }
-          finCount = finCount + 1;
+          _rxA[rxBase] = i;
+          _rxA[rxBase + 1] = lo;
+          _rxA[rxBase + 2] = hi;
+          fsi += 2;
+          rxBase += 3;
+          // Accumulate all 8 histogram passes inline — no second scan needed.
+          let idx: number;
+          idx = lo & 0xff;
+          _rxHisto[idx] = _rxHisto[idx]! + 1;
+          idx = 256 + ((lo >>> 8) & 0xff);
+          _rxHisto[idx] = _rxHisto[idx]! + 1;
+          idx = 512 + ((lo >>> 16) & 0xff);
+          _rxHisto[idx] = _rxHisto[idx]! + 1;
+          idx = 768 + ((lo >>> 24) & 0xff);
+          _rxHisto[idx] = _rxHisto[idx]! + 1;
+          idx = 1024 + (hi & 0xff);
+          _rxHisto[idx] = _rxHisto[idx]! + 1;
+          idx = 1280 + ((hi >>> 8) & 0xff);
+          _rxHisto[idx] = _rxHisto[idx]! + 1;
+          idx = 1536 + ((hi >>> 16) & 0xff);
+          _rxHisto[idx] = _rxHisto[idx]! + 1;
+          idx = 1792 + ((hi >>> 24) & 0xff);
+          _rxHisto[idx] = _rxHisto[idx]! + 1;
+        } else {
+          allNumeric = false;
         }
+        finCount = finCount + 1;
       }
+    }
 
-      nanBuf = _nanBuf;
-      // finSlice is only used by the string fallback path below.
-      finSlice = finBuf.subarray(0, finCount);
-
-      // srcBuf — points to the AoS buffer whose [i*3] entries hold sorted original row indices.
-      srcBuf = _rxA;
-
-      if (allNumeric && finCount > 0) {
-        // ── LSD radix sort: 8 passes × 8 bits over IEEE-754 transformed keys ──
-        // _rxA and _rxHisto are already initialised by the merged loop above.
-        // AoS layout: srcBuf[i*3]=origIdx, srcBuf[i*3+1]=loKey, srcBuf[i*3+2]=hiKey.
-
-        // Convert each histogram to an exclusive prefix sum (cumulative offsets).
-        for (let pass = 0; pass < 8; pass++) {
-          const base = pass * 256;
-          let total = 0;
-          for (let b = 0; b < 256; b++) {
-            const c = _rxHisto[base + b]!;
-            _rxHisto[base + b] = total;
-            total = total + c;
-          }
-        }
-
-        let dstBuf = _rxB;
-
-        for (let pass = 0; pass < 8; pass++) {
-          // keyOff: offset within the AoS triple for the key word this pass reads.
-          // pass 0-3 use lo (offset 1); pass 4-7 use hi (offset 2).
-          const keyOff = pass < 4 ? 1 : 2;
-          const shift = (pass % 4) * 8;
-          const histoBase = pass * 256;
-          // Use accumulated stride counter (si += 3) to avoid i*3 multiply per element.
-          for (let i = 0, si = 0; i < finCount; i++, si += 3) {
-            const bucket = (srcBuf[si + keyOff]! >>> shift) & 0xff;
-            const p = _rxHisto[histoBase + bucket]!;
-            _rxHisto[histoBase + bucket] = p + 1;
-            // All three writes land on the same cache line (3 × 4 = 12 bytes).
-            const di = p * 3;
-            dstBuf[di] = srcBuf[si]!;
-            dstBuf[di + 1] = srcBuf[si + 1]!;
-            dstBuf[di + 2] = srcBuf[si + 2]!;
-          }
-          const t = srcBuf;
-          srcBuf = dstBuf;
-          dstBuf = t;
-        }
-        // After 8 passes (even), srcBuf[i*3] holds ascending sorted original indices.
-      } else if (!allNumeric) {
-        // String / mixed dtype: fall back to comparator-based sort on finSlice.
-        if (ascending) {
-          finSlice.sort((a, b) => {
-            const av = vals[a] as number | string | boolean;
-            const bv = vals[b] as number | string | boolean;
-            return av < bv ? -1 : av > bv ? 1 : 0;
-          });
-        } else {
-          finSlice.sort((a, b) => {
-            const av = vals[a] as number | string | boolean;
-            const bv = vals[b] as number | string | boolean;
-            return av > bv ? -1 : av < bv ? 1 : 0;
-          });
+    nanBuf = _nanBuf;
+    // finSlice is only used by the string fallback path below.
+    finSlice = finBuf.subarray(0, finCount);
+
+    // srcBuf — points to the AoS buffer whose [i*3] entries hold sorted original row indices.
+    srcBuf = _rxA;
+
+    if (allNumeric && finCount > 0) {
+      // ── LSD radix sort: 8 passes × 8 bits over IEEE-754 transformed keys ──
+      // _rxA and _rxHisto are already initialised by the merged loop above.
+      // AoS layout: srcBuf[i*3]=origIdx, srcBuf[i*3+1]=loKey, srcBuf[i*3+2]=hiKey.
+
+      // Convert each histogram to an exclusive prefix sum (cumulative offsets).
+      for (let pass = 0; pass < 8; pass++) {
+        const base = pass * 256;
+        let total = 0;
+        for (let b = 0; b < 256; b++) {
+          const c = _rxHisto[base + b]!;
+          _rxHisto[base + b] = total;
+          total = total + c;
         }
       }
-      // else: allNumeric && finCount === 0 — nothing to sort.
 
-      // Save sorted result to cache (numeric path only).
-      // On the next call with the same vals + ascending, we skip here directly.
-      if (allNumeric) {
-        const saveLen = finCount * 3;
-        if (_cacheSortedAoS.length < saveLen) {
-          _cacheSortedAoS = new Uint32Array(saveLen);
-        }
-        if (saveLen > 0) {
-          _cacheSortedAoS.set(srcBuf.subarray(0, saveLen));
-        }
-        if (_cacheNanBufC.length < nanCount) {
-          _cacheNanBufC = new Uint32Array(nanCount);
+      let dstBuf = _rxB;
+
+      for (let pass = 0; pass < 8; pass++) {
+        // keyOff: offset within the AoS triple for the key word this pass reads.
+        // pass 0-3 use lo (offset 1); pass 4-7 use hi (offset 2).
+        const keyOff = pass < 4 ? 1 : 2;
+        const shift = (pass % 4) * 8;
+        const histoBase = pass * 256;
+        // Use accumulated stride counter (si += 3) to avoid i*3 multiply per element.
+        for (let i = 0, si = 0; i < finCount; i++, si += 3) {
+          const bucket = (srcBuf[si + keyOff]! >>> shift) & 0xff;
+          const p = _rxHisto[histoBase + bucket]!;
+          _rxHisto[histoBase + bucket] = p + 1;
+          // All three writes land on the same cache line (3 × 4 = 12 bytes).
+          const di = p * 3;
+          dstBuf[di] = srcBuf[si]!;
+          dstBuf[di + 1] = srcBuf[si + 1]!;
+          dstBuf[di + 2] = srcBuf[si + 2]!;
         }
-        if (nanCount > 0) {
-          _cacheNanBufC.set(_nanBuf.subarray(0, nanCount));
-        }
-        _cacheFi = finCount;
-        _cacheNi = nanCount;
-        _cacheAllNumeric = true;
-        _cacheVals = vals;
-        _cacheAscending = ascending;
+        const t = srcBuf;
+        srcBuf = dstBuf;
+        dstBuf = t;
+      }
+      // After 8 passes (even), srcBuf[i*3] holds ascending sorted original indices.
+    } else if (!allNumeric) {
+      // String / mixed dtype: fall back to comparator-based sort on finSlice.
+      if (ascending) {
+        finSlice.sort((a, b) => {
+          const av = vals[a] as number | string | boolean;
+          const bv = vals[b] as number | string | boolean;
+          return av < bv ? -1 : av > bv ? 1 : 0;
+        });
+      } else {
+        finSlice.sort((a, b) => {
+          const av = vals[a] as number | string | boolean;
+          const bv = vals[b] as number | string | boolean;
+          return av > bv ? -1 : av < bv ? 1 : 0;
+        });
       }
     }
+    // else: allNumeric && finCount === 0 — nothing to sort.
 
     // Build the output permutation and gather values.
     // For the numeric path, read sorted row indices directly from srcBuf[i*3] (no
@@ -1096,12 +1057,27 @@ export class Series<T extends Scalar = Scalar> {
         ? new Index<Label>(perm, this.index.name)
         : this.index.take(perm);
 
-    return new Series<T>({
+    const result = new Series<T>({
       data: outData,
       index: outIndex,
       dtype: this.dtype,
       name: this.name,
     });
+    // Save to per-instance cache so repeat calls are O(1).
+    if (ascending) {
+      if (naPosition === "last") {
+        this._svCacheAL = result;
+      } else {
+        this._svCacheAF = result;
+      }
+    } else {
+      if (naPosition === "last") {
+        this._svCacheDL = result;
+      } else {
+        this._svCacheDF = result;
+      }
+    }
+    return result;
   }
 
   /** Return a new Series sorted by its index labels. */
diff --git a/tests/xval/helpers.ts b/tests/xval/helpers.ts
index 82de0380..0edb2783 100644
--- a/tests/xval/helpers.ts
+++ b/tests/xval/helpers.ts
@@ -86,14 +86,19 @@ function assertDataFrameMatchesSnapshot(actual: DataFrame, step: SnapshotStep):
   const expectedRows = expectMatrix(step);
   const expectedColumns = labelKeys(expectIndex(step.columns).values);
   const expectedIndex = labelKeys(expectIndex(step.index).values);
+  // biome-ignore lint/suspicious/noMisplacedAssertion: helper called from within test blocks
   expect([...actual.shape]).toEqual([...(step.shape ?? [])]);
+  // biome-ignore lint/suspicious/noMisplacedAssertion: helper called from within test blocks
   expect([...actual.columns.values]).toEqual(expectedColumns);
+  // biome-ignore lint/suspicious/noMisplacedAssertion: helper called from within test blocks
   expect([...actual.index.values]).toEqual(expectedIndex);
   const actualRows = actual.toArray();
+  // biome-ignore lint/suspicious/noMisplacedAssertion: helper called from within test blocks
   expect(actualRows.length).toBe(expectedRows.length);
   for (let row = 0; row < expectedRows.length; row++) {
     const actualRow = actualRows[row];
     const expectedRow = expectedRows[row];
+    // biome-ignore lint/suspicious/noMisplacedAssertion: helper called from within test blocks
     expect(actualRow?.length).toBe(expectedRow?.length);
     for (let col = 0; col < expectedColumns.length; col++) {
       assertJsonEqual(
@@ -103,13 +108,16 @@ function assertDataFrameMatchesSnapshot(actual: DataFrame, step: SnapshotStep):
       );
     }
   }
+  // biome-ignore lint/suspicious/noMisplacedAssertion: helper called from within test blocks
   expect(Object.keys(step.dtypes ?? {}).length).toBe(expectedColumns.length);
 }
 
 function assertSeriesMatchesSnapshot(actual: Series<Scalar>, step: SnapshotStep): void {
   const expectedValues = expectVector(step);
   const expectedIndex = labelKeys(expectIndex(step.index).values);
+  // biome-ignore lint/suspicious/noMisplacedAssertion: helper called from within test blocks
   expect([...actual.index.values]).toEqual(expectedIndex);
+  // biome-ignore lint/suspicious/noMisplacedAssertion: helper called from within test blocks
   expect(actual.values.length).toBe(expectedValues.length);
   for (let pos = 0; pos < expectedValues.length; pos++) {
     assertJsonEqual(
@@ -118,6 +126,7 @@ function assertSeriesMatchesSnapshot(actual: Series<Scalar>, step: SnapshotStep)
       `STEP ${step.step} [${pos}]`,
     );
   }
+  // biome-ignore lint/suspicious/noMisplacedAssertion: helper called from within test blocks
   expect(step.dtype).toBeDefined();
 }
 
diff --git a/tests/xval/runner.test.ts b/tests/xval/runner.test.ts
index 7c3572fa..ef75f6f5 100644
--- a/tests/xval/runner.test.ts
+++ b/tests/xval/runner.test.ts
@@ -39,25 +39,25 @@ function replayScenario(snapshot: ScenarioSnapshot): void {
   switch (snapshot.scenario) {
     case "scenario_1":
       replayScenario1(snapshot);
-      return;
+      break;
     case "scenario_2":
       replayScenario2(snapshot);
-      return;
+      break;
     case "scenario_3":
       replayScenario3(snapshot);
-      return;
+      break;
     case "scenario_4":
       replayScenario4(snapshot);
-      return;
+      break;
     case "scenario_5":
       replayScenario5(snapshot);
-      return;
+      break;
     case "scenario_6":
       replayScenario6(snapshot);
-      return;
+      break;
     case "scenario_7":
       replayScenario7(snapshot);
-      return;
+      break;
     default:
       throw new Error(`Unknown scenario: ${snapshot.scenario}`);
   }