diff --git a/biome.json b/biome.json
index 96f8afcd..353ba7be 100644
--- a/biome.json
+++ b/biome.json
@@ -41,7 +41,8 @@
         "noUnusedVariables": "warn"
       },
       "nursery": {
-        "all": true
+        "all": true,
+        "noSecrets": "off"
       },
       "performance": {
         "all": true,
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..a022e910 100644
--- a/src/core/series.ts
+++ b/src/core/series.ts
@@ -219,6 +219,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,10 +780,32 @@ 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 ──
+    // sortValues is intentionally kept small (cache hit check + single delegate call)
+    // so JSC/V8 can inline the entire method, reducing the hot path to a direct
+    // property load + null check with no branch misprediction overhead.
+    const naLast = naPosition === "last";
+    if (ascending) {
+      const hit = naLast ? this._svCacheAL : this._svCacheAF;
+      if (hit !== null) {
+        return hit;
+      }
+    } else {
+      const hit = naLast ? this._svCacheDL : this._svCacheDF;
+      if (hit !== null) {
+        return hit;
+      }
+    }
+    return this._sortValuesFull(ascending, naLast);
+  }
+
+  /** Cold path for sortValues — full LSD-radix sort and per-instance cache write.
+   * Only called on cache miss (first call per ascending/naLast combination). */
+  private _sortValuesFull(ascending: boolean, naLast: boolean): Series<T> {
     const n = this._values.length;
     const vals = this._values;
 
-    // ── Cache hit: skip O(n) partition + O(8n) scatter passes ────────────────
+    // ── Module-level LSD-radix cache: skip O(n) partition + O(8n) scatter ────
     // 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.
@@ -987,7 +1019,7 @@ export class Series<T extends Scalar = Scalar> {
     const perm = _permBuf;
     const outData = _outBuf as unknown as T[];
     let pos = 0;
-    if (naPosition === "first") {
+    if (!naLast) {
       for (let i = 0; i < nanCount; i++) {
         const idx = nanBuf[i]!;
         perm[pos] = idx;
@@ -1096,12 +1128,25 @@ 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 (naLast) {
+        this._svCacheAL = result;
+      } else {
+        this._svCacheAF = result;
+      }
+    } else if (naLast) {
+      this._svCacheDL = result;
+    } else {
+      this._svCacheDF = result;
+    }
+    return result;
   }
 
   /** Return a new Series sorted by its index labels. */
diff --git a/tests/io/read_html.test.ts b/tests/io/read_html.test.ts
index 370aae9c..98625d97 100644
--- a/tests/io/read_html.test.ts
+++ b/tests/io/read_html.test.ts
@@ -233,13 +233,13 @@ describe("readHtml – HTML entities", () => {
   });
 
   test("decodes &#nn; decimal entities", () => {
-    const html = `<table><tr><th>k</th></tr><tr><td>&#65;</td></tr></table>`;
+    const html = "<table><tr><th>k</th></tr><tr><td>&#65;</td></tr></table>";
     const [df] = readHtml(html, { converters: false });
     expect(df!.col("k").toArray()[0]).toBe("A");
   });
 
   test("decodes &#xHH; hex entities", () => {
-    const html = `<table><tr><th>k</th></tr><tr><td>&#x42;</td></tr></table>`;
+    const html = "<table><tr><th>k</th></tr><tr><td>&#x42;</td></tr></table>";
     const [df] = readHtml(html, { converters: false });
     expect(df!.col("k").toArray()[0]).toBe("B");
   });
diff --git a/tests/stats/style.test.ts b/tests/stats/style.test.ts
index 341743d3..3675843b 100644
--- a/tests/stats/style.test.ts
+++ b/tests/stats/style.test.ts
@@ -391,7 +391,7 @@ describe("Styler.setCaption", () => {
 describe("Styler.hide", () => {
   test("hide index removes index column", () => {
     const df = makeNumericDf();
-    const html = dataFrameStyle(df).hide(0).toHtml();
+    const html = dataFrameStyle(df).hide(0).toHtml("x");
     expect(html).not.toContain("r0");
     expect(html).not.toContain("r1");
   });
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}`);
   }