perf(bench): mitata hot-path suite + committed baseline RESULTS; pnpm bench

Author: MesTTo

package.json

@@ -13,14 +13,16 @@
     "lint": "eslint \"packages/*/src/**/*.ts\"",
     "format": "prettier --write \"packages/*/src/**/*.ts\" \"*.{json,md}\"",
     "format:check": "prettier --check \"packages/*/src/**/*.ts\" \"*.{json,md}\"",
-    "oracle": "vitest run packages/core/src/oracle.test.ts"
+    "oracle": "vitest run packages/core/src/oracle.test.ts",
+    "bench": "pnpm --filter @metta-ts/core build && node packages/node/bench/suite.mjs"
   },
   "devDependencies": {
     "@types/node": "^22.20.0",
     "@vitest/coverage-v8": "^2.1.8",
     "eslint": "^10.5.0",
     "eslint-config-prettier": "^10.1.8",
     "fast-check": "^3.23.1",
+    "mitata": "^1.0.34",
     "prettier": "^3.8.4",
     "tsup": "^8.3.5",
     "typescript": "^5.6.3",

packages/node/bench/RESULTS.md

@@ -1,11 +1,19 @@
 # Benchmark results
 
-Pure TypeScript, no native addon, no WASM. Node v22, single core. Run: `pnpm --filter @metta-ts/core build && node packages/node/bench/bench.mjs`.
+Pure TypeScript, no native addon, no WASM. Node v22, single core.
+Run: `pnpm --filter @metta-ts/core build && node packages/node/bench/suite.mjs` (deopt-aware mitata).
 
-| benchmark | time |
-|-----------|------|
-| stdlib parse + load + `(+ 1 2)` (prelude cached) | ~0.07 ms |
-| `fib(18)` naive double-recursion (~10.9k calls) | ~185 ms |
-| full 270-assertion Hyperon oracle (22 files) | ~134 ms |
+## Hot paths (mitata)
 
-These are correctness-first numbers (a faithful tree-walker; `buildEnv` is rebuilt per query, no memoization). The Phase-15 roadmap (staging/partial-evaluation, a flat interned atom core, a bytecode VM, a `mnemonist` AtomSpace index) targets the hot paths these expose, each gated by the 270/270 oracle so speed never costs correctness.
+| benchmark | time/iter | notes |
+|-----------|-----------|-------|
+| `matchAtoms` symbol mismatch | ~10 ns | the fast-reject path |
+| `matchAtoms` nested, binds 2 vars | ~212 ns | 21× the mismatch cost |
+| `match` over a 1000-atom space | ~321 µs | linear scan (Phase-15 index targets this) |
+| `fib(15)` (~1.2k recursive calls) | ~27 ms | tree-walker, no memoization |
+| stdlib load + `(+ 1 2)` | ~13 µs | prelude atoms cached |
+| full 270-assertion Hyperon oracle | ~62 ms | all 22 files, `buildEnv` per query |
+
+## Reading these
+
+Correctness-first numbers from a faithful tree-walker. The clear hot spots — per-query `buildEnv`, the linear space scan, and the `mettaEval` allocation in `fib` — are exactly what the Phase-15 roadmap targets (staging/partial-evaluation, a flat interned atom core, a bytecode VM, a `mnemonist` AtomSpace index). Every optimization is gated by the 270/270 oracle so speed never costs correctness, and must show a before/after number here.

packages/node/bench/suite.mjs

@@ -0,0 +1,69 @@
+// Deopt-aware benchmark suite (mitata) for the MeTTa TS hot paths. Pure TypeScript, no native.
+// Run after building core: `node packages/node/bench/suite.mjs`
+import { run, bench, group, summary } from "mitata";
+import {
+  runProgram,
+  matchAtoms,
+  buildEnv,
+  evalAtom,
+  stdTable,
+  sym,
+  variable,
+  expr,
+  gint,
+  parseAll,
+  standardTokenizer,
+  preludeAtoms,
+} from "../../core/dist/index.js";
+import { readFileSync, readdirSync } from "node:fs";
+import { resolve } from "node:path";
+
+const tk = standardTokenizer();
+const CORPUS = resolve(process.cwd(), "corpus");
+const corpus = readdirSync(CORPUS)
+  .filter((f) => f.endsWith(".metta") && f !== "c2_spaces_kb.metta")
+  .map((f) => readFileSync(resolve(CORPUS, f), "utf8"));
+
+// Hot-path microbenchmarks
+const deep = expr([variable("x"), expr([variable("y"), sym("a")]), gint(3)]);
+const deepT = expr([sym("p"), expr([sym("q"), sym("a")]), gint(3)]);
+
+group("matcher", () => {
+  summary(() => {
+    bench("matchAtoms (nested, binds 2 vars)", () => matchAtoms(deep, deepT));
+    bench("matchAtoms (symbol mismatch)", () => matchAtoms(sym("a"), sym("b")));
+  });
+});
+
+// A space with 1000 facts, query one
+const facts = Array.from({ length: 1000 }, (_, i) => expr([sym("Edge"), gint(i), gint(i + 1)]));
+const big = buildEnv([...preludeAtoms(), ...facts], stdTable());
+const query = expr([sym("match"), sym("&self"), expr([sym("Edge"), gint(500), variable("y")]), variable("y")]);
+group("space", () => {
+  bench("match over 1000-atom space", () => evalAtom(big, query));
+});
+
+// Evaluation
+const fibEnv = buildEnv(
+  [
+    ...preludeAtoms(),
+    ...parseAll(
+      "(= (fib $n) (unify $n 0 0 (unify $n 1 1 (+ (fib (- $n 1)) (fib (- $n 2))))))",
+      tk,
+    ).map((t) => t.atom),
+  ],
+  stdTable(),
+);
+const fib15 = parseAll("(fib 15)", tk)[0].atom;
+group("eval", () => {
+  bench("fib(15) (~1.2k recursive calls)", () => evalAtom(fibEnv, fib15));
+  bench("stdlib load + (+ 1 2)", () => runProgram("!(+ 1 2)"));
+});
+
+group("oracle", () => {
+  bench("full 270-assertion corpus", () => {
+    for (const src of corpus) runProgram(src);
+  });
+});
+
+await run();