perf(core): incremental env build (extend per atom, not rebuild per query); oracle 270/270

Author: MesTTo

packages/core/src/eval.ts

@@ -146,34 +146,52 @@ export function extractRules(atoms: readonly Atom[]): Array<[Atom, Atom]> {
   return out;
 }
 
-export function buildEnv(atoms: Atom[], gt: GroundingTable): MinEnv {
-  const rules = extractRules(atoms);
-  const ruleIndex = new Map<string, Array<[Atom, Atom]>>();
-  const varRules: Array<[Atom, Atom]> = [];
-  for (const [lhs, rhs] of rules) {
+/** An empty environment for grounding table `gt`. Grow it with `addAtomToEnv`. */
+export function emptyEnv(gt: GroundingTable): MinEnv {
+  return {
+    ruleIndex: new Map(),
+    varRules: [],
+    sigs: new Map(),
+    gt,
+    atoms: [],
+    types: new Map(),
+    imports: new Map(),
+    exprTypes: [],
+  };
+}
+
+/** Incorporate one atom into `env` (mutating): rule index, signatures, types, and the atom list.
+ *  Lets a sequential runner extend the env per atom instead of rebuilding it each query (Phase-15
+ *  optimization; the 270/270 oracle gates it). */
+export function addAtomToEnv(env: MinEnv, x: Atom): void {
+  env.atoms.push(x);
+  if (opOf(x) === "=" && x.kind === "expr" && x.items.length === 3) {
+    const lhs = x.items[1]!;
+    const rhs = x.items[2]!;
     const k = headKey(lhs);
-    if (k === undefined) varRules.push([lhs, rhs]);
+    if (k === undefined) env.varRules.push([lhs, rhs]);
     else {
-      const cur = ruleIndex.get(k) ?? [];
-      cur.push([lhs, rhs]);
-      ruleIndex.set(k, cur);
+      const cur = env.ruleIndex.get(k);
+      if (cur === undefined) env.ruleIndex.set(k, [[lhs, rhs]]);
+      else cur.push([lhs, rhs]);
     }
   }
-  const sigs = new Map<string, Atom[]>();
-  const types = new Map<string, Atom[]>();
-  const exprTypes: Array<[Atom, Atom]> = [];
-  for (const x of atoms) {
-    if (x.kind !== "expr" || opOf(x) !== ":" || x.items.length !== 3) continue;
+  if (x.kind === "expr" && opOf(x) === ":" && x.items.length === 3) {
     const subj = x.items[1]!;
     const t = x.items[2]!;
     if (subj.kind === "sym") {
-      if (opOf(t) === "->" && t.kind === "expr") sigs.set(subj.name, t.items.slice(1));
-      types.set(subj.name, [...(types.get(subj.name) ?? []), t]);
+      if (opOf(t) === "->" && t.kind === "expr") env.sigs.set(subj.name, t.items.slice(1));
+      env.types.set(subj.name, [...(env.types.get(subj.name) ?? []), t]);
     } else if (subj.kind === "expr") {
-      exprTypes.push([subj, t]);
+      env.exprTypes.push([subj, t]);
     }
   }
-  return { ruleIndex, varRules, sigs, gt, atoms, types, imports: new Map(), exprTypes };
+}
+
+export function buildEnv(atoms: Atom[], gt: GroundingTable): MinEnv {
+  const env = emptyEnv(gt);
+  for (const x of atoms) addAtomToEnv(env, x);
+  return env;
 }
 
 function candidates(env: MinEnv, toEval: Atom): Array<[Atom, Atom]> {

packages/core/src/runner.ts

@@ -4,7 +4,7 @@
 import { type Atom, gint, gfloat, gbool } from "./atom";
 import { Tokenizer } from "./tokenizer";
 import { parseAll, format } from "./parser";
-import { type St, type MinEnv, buildEnv, initSt, mettaEval } from "./eval";
+import { type St, type MinEnv, buildEnv, addAtomToEnv, initSt, mettaEval } from "./eval";
 import { stdTable } from "./builtins";
 import { PRELUDE_SRC } from "./prelude";
 
@@ -42,15 +42,17 @@ export function evalSequential(
   imports: Map<string, Atom[]> = new Map(),
 ): QueryResult[] {
   const out: QueryResult[] = [];
-  const kb: Atom[] = [];
   let st: St = initSt();
-  const prelude = preludeAtoms();
+  // Build the env once and extend it per non-bang atom (Phase-15 optimization: the old code
+  // rebuilt the whole env on every query). Sequential semantics hold because each atom is added
+  // before the queries that follow it. The 270/270 oracle gates this.
+  const env: MinEnv = buildEnv([...preludeAtoms()], stdTable());
+  env.imports = imports;
   for (const { atom, bang } of atoms) {
     if (!bang) {
-      kb.push(atom);
+      addAtomToEnv(env, atom);
       continue;
     }
-    const env: MinEnv = { ...buildEnv([...prelude, ...kb], stdTable()), imports };
     const [pairs, st2] = mettaEval(env, fuel, st, [], atom);
     st = st2;
     out.push({ query: atom, results: pairs.map((p) => p[0]) });