eyeprolog 1.3.3 → 1.3.7

package/src/solver.js

@@ -5,15 +5,18 @@ import {
   flattenConjunction, freshTerm, isCons, isDecimalInteger, isEmptyList,
   numberTerm, numberTextFromDouble, termIsGround, termToString, unify, variable, variantTerms,
 } from './term.js';
-import { sameNumberValue } from './number-value.js';
+import { numberValueKey, sameNumberValue } from './number-value.js';
 import { PrologError, getStrictIsoRegistry } from './iso.js';
 import { getEyePrologRegistry } from './standard-library.js';
 import { selectClauseCandidates, selectClauseCandidatesForValues, selectGroundClauseCandidates } from './program.js';
 import { StreamManager } from './io.js';
 import { clpzStateConsistent } from './clpz.js';
 import { hardHeapLimit, softHeapLimit, usedHeapSize } from './platform.js';
+import { evaluateWfs, relationForGroup, truthOfGroundGoal } from './wfs.js';
+import { evaluatePositiveDatalog, relationForDatalogGroup, datalogCandidateIndexes } from './datalog.js';
 
 let freshCounter = 0;
+const DEFAULT_INNER_TABLE_SCOPE_LIMIT = 1024;
 
 function qualifyTerm(term, module) {
   if (!term || (term.type !== COMPOUND && term.type !== 'atom')) return term;
@@ -62,6 +65,9 @@ export class Solver {
     // still supply solutionLimit explicitly.
     this.solutionLimit = options.solutionLimit ?? Infinity;
     this.solutionsSeen = 0;
+    // Meta-call fast path: a caller may bypass automatic tabling only for
+    // recursion proven to consume a list tail on every recursive step.
+    this.skipListTailTabling = options.skipListTailTabling === true;
     this.prologFlags = options.prologFlags ?? defaultPrologFlags('error', this.isoStrict);
     if (this.isoStrict) {
       for (const name of [...this.prologFlags.keys()]) {
@@ -104,9 +110,17 @@ export class Solver {
     this.active = [];
     this.cutEpoch = 0;
     this.memo = new Map();
+    this.subsumptiveMemo = new Map();
+    this.wfsModels = new Map();
+    this.datalogModels = new Map();
     this.tableCoordinator = null;
     this.groundChainSuccess = new Set();
     this.compactChainSuccess = new Map();
+    // Bounded table caches for isolated meta-call domains such as phrase/2-3.
+    // They deliberately do not share the caller's general memo: a stream of
+    // distinct meta-call inputs must not turn completed table variants into
+    // process-lifetime roots.
+    this.innerTableScopes = options.innerTableScopes ?? new Map();
     this.stats = {
       completed_goal_lists: 0,
       solve_goals_calls: 0,
@@ -117,10 +131,15 @@ export class Solver {
       deterministic_builtin_successes: 0,
       deterministic_builtin_failures: 0,
       table_fixpoint_rounds: 0,
+      datalog_evaluations: 0,
+      datalog_rule_firings: 0,
+      datalog_facts_derived: 0,
+      wfs_fixpoint_rounds: 0,
+      wfs_undefined_answers: 0,
     };
   }
 
-  cloneForInnerGoal(solutionLimit = this.solutionLimit) {
+  cloneForInnerGoal(solutionLimit = this.solutionLimit, options = {}) {
     const solver = new Solver(this.program, {
       registry: this.registry,
       maxDepth: this.maxDepth,
@@ -132,13 +151,74 @@ export class Solver {
       prologFlags: this.prologFlags,
       charConversions: this.charConversions,
       io: this.io,
+      innerTableScopes: this.innerTableScopes,
+      skipListTailTabling: options.skipListTailTabling ?? this.skipListTailTabling,
     });
-    solver.memo = this.memo;
+    if (options.tableScope != null) {
+      const scope = this.innerTableScope(options.tableScope, options.tableScopeSignature ?? null);
+      solver.memo = scope.memo;
+      solver.subsumptiveMemo = scope.subsumptiveMemo;
+    } else {
+      solver.memo = this.memo;
+      solver.subsumptiveMemo = this.subsumptiveMemo;
+    }
+    solver.wfsModels = this.wfsModels;
+    solver.datalogModels = this.datalogModels;
     solver.groundChainSuccess = this.groundChainSuccess;
     solver.compactChainSuccess = this.compactChainSuccess;
     return solver;
   }
 
+  innerTableScope(name, signature = null) {
+    let scope = this.innerTableScopes.get(name);
+    if (scope == null) {
+      scope = { memo: new Map(), subsumptiveMemo: new Map(), signature };
+      this.innerTableScopes.set(name, scope);
+      return scope;
+    }
+    if (signature == null || scope.signature === signature) return scope;
+
+    // Keep at most one completed invocation variant for isolated meta-call
+    // domains. Reusing the same phrase/2-3 call remains fast, while a stream of
+    // distinct inputs releases the previous table as one unit instead of
+    // churning thousands of individual memo entries. A nested meta-call must
+    // not invalidate an active fixed point, so it receives a temporary scope.
+    for (const entry of scope.memo.values()) {
+      if (entry?.computing === true) {
+        return { memo: new Map(), subsumptiveMemo: new Map(), signature };
+      }
+    }
+    scope.memo.clear();
+    scope.subsumptiveMemo.clear();
+    scope.signature = signature;
+    return scope;
+  }
+
+  innerTableSignature(terms, env, prefix = '') {
+    const variables = new Map();
+    return prefix + terms.map((term) => canonicalTermKey(term, env, variables)).join('|');
+  }
+
+  trimInnerTableScope(name, limit = DEFAULT_INNER_TABLE_SCOPE_LIMIT) {
+    const scope = this.innerTableScopes.get(name);
+    if (scope == null || scope.memo.size <= limit) return;
+    // Map iteration is insertion ordered. Delete completed entries directly by
+    // key as we encounter them so a steady stream of distinct meta-call inputs
+    // pays O(evictions), not an O(cache-size) rescan for every phrase/2 call.
+    // Active fixed-point entries are skipped and can only make the cache
+    // temporarily exceed its soft bound.
+    for (const [key, entry] of scope.memo) {
+      if (scope.memo.size <= limit) break;
+      if (entry?.complete !== true || entry?.computing === true) continue;
+      scope.memo.delete(key);
+      if (scope.subsumptiveMemo.size !== 0) {
+        for (const [broadKey, broadEntry] of scope.subsumptiveMemo) {
+          if (broadEntry === entry) scope.subsumptiveMemo.delete(broadKey);
+        }
+      }
+    }
+  }
+
   syncProgramRevision() {
     if (!this.mutableProgram) {
       if (this.program.mutable !== true) return;
@@ -148,9 +228,16 @@ export class Solver {
     if (revision === this.programRevision) return;
     this.programRevision = revision;
     this.memo.clear();
+    this.subsumptiveMemo.clear();
+    this.wfsModels.clear();
+    this.datalogModels.clear();
     this.tableCoordinator = null;
     this.groundChainSuccess.clear();
     this.compactChainSuccess.clear();
+    for (const scope of this.innerTableScopes.values()) {
+      scope.memo.clear();
+      scope.subsumptiveMemo.clear();
+    }
   }
 
   absorbStatsFrom(child) {
@@ -330,6 +417,19 @@ export class Solver {
         if (goal.type === 'var') throw new PrologError('instantiation_error');
         const callable = goal.type === COMPOUND || goal.type === 'atom';
         if (!callable) throw new PrologError('type_error(callable)', goal);
+
+        if (selectedIndex === 0) {
+          const fused = findallLengthFusion(this, goal, rest, env);
+          if (fused != null) {
+            const firstResult = fused.iterator.next();
+            if (firstResult.done) break;
+            goals = fused.rest;
+            env = firstResult.value;
+            depth++;
+            continue;
+          }
+        }
+
         const def = callable ? this.registry.get(goal.name, goal.arity) : null;
         this.active = active;
         if (def && builtinIsReadyOrAuthoritative(def, this, goal, env)) {
@@ -374,7 +474,49 @@ export class Solver {
         }
         qualifyMetaArguments(goal, group);
 
-        const lengthIterator = prologueLengthIterator(this, group, goal, env);
+        if (group.datalogLeastModel === true && !termIsGround(goal, env)) {
+          const model = this.datalogModelFor(group);
+          const relation = relationForDatalogGroup(model, group);
+          const iterator = datalogAnswerSolutions(this, relation, goal, env);
+          const firstResult = iterator.next();
+          if (firstResult.done) break;
+          stack.push({
+            kind: 'resumeBuiltin',
+            iterator,
+            goals: rest,
+            depth: depth + 1,
+            active,
+          });
+          goals = rest;
+          env = firstResult.value;
+          depth++;
+          continue;
+        }
+
+        if (group.wfsDatalog === true) {
+          const model = this.wfsModelFor(group);
+          pushWfsAnswerFrames(stack, model, group, goal, rest, env, depth, active, this);
+          break;
+        }
+
+        const memberIterator = bundledMemberIterator(this, group, goal, env);
+        if (memberIterator != null) {
+          const firstResult = memberIterator.next();
+          if (firstResult.done) break;
+          stack.push({
+            kind: 'resumeBuiltin',
+            iterator: memberIterator,
+            goals: rest,
+            depth: depth + 1,
+            active,
+          });
+          goals = rest;
+          env = firstResult.value;
+          depth++;
+          continue;
+        }
+
+        const lengthIterator = bundledLengthIterator(this, group, goal, env);
         if (lengthIterator != null) {
           const firstResult = lengthIterator.next();
           if (firstResult.done) break;
@@ -391,14 +533,29 @@ export class Solver {
           continue;
         }
 
-        if (group.tabled) {
+        if (group.tabled && !(this.skipListTailTabling && group.listTailRecursive)) {
           const key = memoKey(goal, env, group);
           if (key.hasBound) {
             const mapKey = `${group.module}:${goal.name}/${goal.arity}:${key.text}`;
-            let entry = this.memo.get(mapKey);
+            const broadKey = `${group.module}:${goal.name}/${goal.arity}`;
+            let entry = null;
+            let usingBroadTable = false;
+            if (group.tableAllVariants) {
+              entry = this.subsumptiveMemo.get(broadKey) ?? null;
+              usingBroadTable = entry != null;
+              if (!entry && isMostGeneralTableGoal(goal, env)) {
+                entry = makeMemoEntry(goal.arity);
+                this.subsumptiveMemo.set(broadKey, entry);
+                this.memo.set(mapKey, entry);
+                usingBroadTable = true;
+              }
+            }
             if (!entry) {
-              entry = makeMemoEntry();
-              this.memo.set(mapKey, entry);
+              entry = this.memo.get(mapKey);
+              if (!entry) {
+                entry = makeMemoEntry(goal.arity);
+                this.memo.set(mapKey, entry);
+              }
             }
             if (this.tableCoordinator) this.tableCoordinator.entries.add(entry);
             if (entry.complete) {
@@ -416,7 +573,7 @@ export class Solver {
               }
               break;
             }
-            if (this.tableCoordinator && activeVariantIn(goal, env, active)) {
+            if (this.tableCoordinator && (usingBroadTable || activeVariantIn(goal, env, active))) {
               this.tableCoordinator.cycleSeen = true;
             }
             pushMemoAnswerFrames(stack, entry, goal, rest, env, depth, active, this);
@@ -449,6 +606,84 @@ export class Solver {
     }
   }
 
+  fastCountGoal(goal, env) {
+    return fastCountPureGoal(this, goal, env);
+  }
+
+  fastGroundGoalTruth(goal, env) {
+    return fastGroundPureGoalTruth(this, goal, env);
+  }
+
+  datalogModelFor(group) {
+    let model = this.datalogModels.get(group);
+    if (model) return model;
+    model = evaluatePositiveDatalog(this.program, group);
+    this.stats.datalog_evaluations++;
+    this.stats.datalog_rule_firings += model.ruleFirings;
+    this.stats.datalog_facts_derived += model.derivedFacts;
+    for (const member of model.groups) {
+      if (!this.datalogModels.has(member)) this.datalogModels.set(member, model);
+    }
+    this.datalogModels.set(group, model);
+    return model;
+  }
+
+  wfsModelFor(group) {
+    let model = this.wfsModels.get(group);
+    if (model) return model;
+    model = evaluateWfs(this.program, group);
+    this.stats.wfs_fixpoint_rounds += model.rounds;
+    this.wfsModels.set(group, model);
+    return model;
+  }
+
+  *solveWfsGoal(group, goal, rest, env, depth) {
+    const model = this.wfsModelFor(group);
+    const relation = relationForGroup(model, group, 'upper');
+    const lower = relationForGroup(model, group, 'lower');
+    if (!relation) return;
+    for (const row of relation.rows) {
+      const next = env.clone();
+      let ok = true;
+      for (let i = 0; i < goal.arity; i++) {
+        this.stats.unify_calls++;
+        if (!unify(goal.args[i], row[i], next)) { ok = false; break; }
+      }
+      if (!ok) continue;
+      if (!lower?.has(row)) this.stats.wfs_undefined_answers++;
+      yield* this.solve(rest, next, depth + 1);
+      if (this.solutionsSeen >= this.solutionLimit) return;
+    }
+  }
+
+  *solveTabledNegation(argument, env) {
+    const invoked = copyResolved(argument, env);
+    if (invoked.type === VAR) throw new PrologError('instantiation_error');
+    if (invoked.type !== COMPOUND && invoked.type !== 'atom') {
+      throw new PrologError('type_error(callable)', invoked);
+    }
+    if (!termIsGround(invoked)) throw new PrologError('instantiation_error');
+    const group = this.program.findGroup(invoked.name, invoked.arity, invoked.module ?? 'user');
+    if (group?.wfsDatalog === true) {
+      const model = this.wfsModelFor(group);
+      const truth = truthOfGroundGoal(model, invoked);
+      if (truth === 'true') return;
+      if (truth === 'undefined') this.stats.wfs_undefined_answers++;
+      yield env;
+      return;
+    }
+
+    // Outside an unstratified WFS component, a ground tabled negation has the
+    // ordinary two-valued result after the positive goal is evaluated.
+    const child = this.cloneForInnerGoal(1);
+    for (const _ of child.solve([invoked], env.clone(), 0)) {
+      this.absorbStatsFrom(child);
+      return;
+    }
+    this.absorbStatsFrom(child);
+    yield env;
+  }
+
   activeVariant(goal, env) {
     return activeVariantIn(goal, env, this.active);
   }
@@ -508,6 +743,14 @@ export class Solver {
     const group = this.program.findGroup(goal.name, goal.arity, goal.module ?? 'user');
     if (!group) return;
     qualifyMetaArguments(goal, group);
+    if (group.datalogLeastModel === true && !termIsGround(goal, env)) {
+      yield* this.solveDatalogGoal(group, goal, rest, env, depth);
+      return;
+    }
+    if (group.wfsDatalog === true) {
+      yield* this.solveWfsGoal(group, goal, rest, env, depth);
+      return;
+    }
     if (group.tabled) {
       yield* this.solveMemoizedGoal(group, goal, rest, env, depth);
       return;
@@ -515,6 +758,15 @@ export class Solver {
     yield* this.solveUserGoalUncached(group, goal, rest, env, depth);
   }
 
+  *solveDatalogGoal(group, goal, rest, env, depth) {
+    const model = this.datalogModelFor(group);
+    const relation = relationForDatalogGroup(model, group);
+    for (const next of datalogAnswerSolutions(this, relation, goal, env)) {
+      yield* this.solve(rest, next, depth + 1);
+      if (this.solutionsSeen >= this.solutionLimit) return;
+    }
+  }
+
   *solveMemoizedGoal(group, goal, rest, env, depth) {
     yield* this.solve([goal, ...rest], env, depth);
   }
@@ -624,8 +876,30 @@ function defaultPrologFlags(unknown = 'error', strictIso = false) {
 }
 
 
-function makeMemoEntry() {
-  return { computing: false, complete: false, answers: [], answerKeys: new Set() };
+function makeMemoEntry(arity = 0) {
+  return {
+    computing: false,
+    complete: false,
+    answers: [],
+    answerKeys: new Set(),
+    answerIndexes: Array.from({ length: arity }, () => new Map()),
+    answerVariableFallbacks: Array.from({ length: arity }, () => []),
+  };
+}
+
+function memoAnswerScalarKey(term) {
+  if (term?.type !== 'atom' && term?.type !== 'string' && term?.type !== 'number') return null;
+  return `${term.type}\u0000${term.type === 'number' ? numberValueKey(term.name) : term.name}`;
+}
+
+function isMostGeneralTableGoal(goal, env) {
+  const seen = new Set();
+  for (const arg of goal.args) {
+    const value = derefForLocal(arg, env);
+    if (value.type !== 'var' || seen.has(value.name)) return false;
+    seen.add(value.name);
+  }
+  return true;
 }
 
 function scheduleTableFixpointRound(stack, solver, frame) {
@@ -663,10 +937,19 @@ function scheduleTableFixpointRound(stack, solver, frame) {
 
 
 function pushMemoAnswerFrames(stack, entry, goal, rest, env, depth, active, solver) {
-  for (let answerIndex = entry.answers.length - 1; answerIndex >= 0; answerIndex--) {
-    // Stored table variables belong to the answer template, not to any caller.
-    // Freshen the complete tuple together so sharing within an answer is kept
-    // while separate replays cannot alias otherwise independent call variables.
+  let selected = null;
+  for (let position = 0; position < goal.arity; position++) {
+    const value = derefForLocal(goal.args[position], env);
+    const key = memoAnswerScalarKey(value);
+    if (key == null) continue;
+    const bucket = entry.answerIndexes[position]?.get(key) ?? [];
+    const fallback = entry.answerVariableFallbacks[position] ?? [];
+    const candidateLength = bucket.length + fallback.length;
+    if (selected == null || candidateLength < selected.length) {
+      selected = { bucket, fallback, length: candidateLength };
+    }
+  }
+  const replay = (answerIndex) => {
     const storedArgs = entry.answers[answerIndex];
     const answerArgs = storedArgs.every((arg) => termIsGround(arg))
       ? storedArgs
@@ -678,12 +961,19 @@ function pushMemoAnswerFrames(stack, entry, goal, rest, env, depth, active, solv
       if (!unify(goal.args[i], answerArgs[i], next)) { ok = false; break; }
     }
     if (ok) stack.push({ kind: 'goals', goals: rest, env: next, depth: depth + 1, active });
+  };
+  if (selected != null) {
+    for (let i = selected.fallback.length - 1; i >= 0; i--) replay(selected.fallback[i]);
+    for (let i = selected.bucket.length - 1; i >= 0; i--) replay(selected.bucket[i]);
+    return;
   }
+  for (let answerIndex = entry.answers.length - 1; answerIndex >= 0; answerIndex--) replay(answerIndex);
 }
 
 function pushUserGoalUncachedFrames(stack, solver, group, goal, rest, env, depth, active) {
   if (group.recursive && !group.cutRecursive && !group.linearNumeric && activeVariantIn(goal, env, active)) return;
   if (group.fastPi && pushFastPiFrames(stack, goal, rest, env, depth, active)) return;
+  if (tryPushGroundScalarRuleFrame(stack, solver, group, goal, rest, env, depth, active)) return;
   if (tryPushGroundChainFrames(stack, solver, group, goal, rest, env, depth, active)) return;
   const candidates = selectClauseCandidates(group, goal, env);
   const frames = [];
@@ -757,9 +1047,79 @@ function groupNeedsActiveFrame(group) {
   return group.cutReachable !== false || (group.recursive && !group.linearNumeric);
 }
 
-function prologueLengthIterator(solver, group, goal, env) {
+function* datalogAnswerSolutions(solver, relation, goal, env) {
+  if (!relation) return;
+  const candidates = datalogCandidateIndexes(
+    relation,
+    goal.args ?? [],
+    env,
+    derefForLocal,
+    memoAnswerScalarKey,
+  );
+  const visit = function* (rowIndex) {
+    const row = relation.rows[rowIndex];
+    const next = env.clone();
+    for (let i = 0; i < goal.arity; i++) {
+      solver.stats.unify_calls++;
+      if (!unify(goal.args[i], row[i], next)) return;
+    }
+    yield next;
+  };
+  if (candidates == null) {
+    for (let rowIndex = 0; rowIndex < relation.rows.length; rowIndex++) yield* visit(rowIndex);
+    return;
+  }
+  for (const rowIndex of candidates) yield* visit(rowIndex);
+}
+
+function pushWfsAnswerFrames(stack, model, group, goal, rest, env, depth, active, solver) {
+  const relation = relationForGroup(model, group, 'upper');
+  const lower = relationForGroup(model, group, 'lower');
+  if (!relation) return;
+  for (let rowIndex = relation.rows.length - 1; rowIndex >= 0; rowIndex--) {
+    const row = relation.rows[rowIndex];
+    const next = env.clone();
+    let ok = true;
+    for (let i = 0; i < goal.arity; i++) {
+      solver.stats.unify_calls++;
+      if (!unify(goal.args[i], row[i], next)) { ok = false; break; }
+    }
+    if (!ok) continue;
+    if (!lower?.has(row)) solver.stats.wfs_undefined_answers++;
+    stack.push({ kind: 'goals', goals: rest, env: next, depth: depth + 1, active });
+  }
+}
+
+function bundledMemberIterator(solver, group, goal, env) {
   if (solver.registry.eyePrologLibrary !== true ||
-      group.module !== 'prologue' || group.name !== 'length' || group.arity !== 2 ||
+      !['lists', 'prologue'].includes(group.module) || group.name !== 'member' || group.arity !== 2 ||
+      group.bundledLibrary !== true || group.clauses.length !== 2) {
+    return null;
+  }
+
+  // Keep the relational/open-list cases in ordinary Prolog.  When the second
+  // argument is already a finite list, however, the canonical two-clause
+  // member/2 definition is exactly a left-to-right scan and can avoid clause
+  // freshening and recursive solver frames for every element.
+  let cursor = deref(goal.args[1], env);
+  while (isCons(cursor)) cursor = deref(cursor.args[1], env);
+  if (!isEmptyList(cursor)) return null;
+  return bundledMemberSolutions(solver, goal, env);
+}
+
+function* bundledMemberSolutions(solver, goal, env) {
+  let cursor = deref(goal.args[1], env);
+  while (isCons(cursor)) {
+    const next = env.clone();
+    solver.stats.unify_calls++;
+    if (unify(goal.args[0], cursor.args[0], next)) yield next;
+    cursor = deref(cursor.args[1], env);
+  }
+}
+
+function bundledLengthIterator(solver, group, goal, env) {
+  if (solver.registry.eyePrologLibrary !== true ||
+      !['lists', 'prologue'].includes(group.module) || group.name !== 'length' || group.arity !== 2 ||
       group.bundledLibrary !== true || group.clauses.length !== 2) {
     return null;
   }
@@ -771,17 +1131,22 @@ function prologueLengthIterator(solver, group, goal, env) {
   if (length.type === VAR && env._delays?.has(length.name)) return null;
 
   let cursor = deref(goal.args[0], env);
-  while (isCons(cursor)) {
-    cursor = deref(cursor.args[1], env);
-  }
-  if (cursor.type === VAR) {
-    if (env._delays?.has(cursor.name)) return null;
-    if (length.type === VAR && cursor.name === length.name) return null;
+  // findall/3 can return an internal compact proper-list spine.  Its length is
+  // already known; do not expand millions of lazy cons cells merely to decide
+  // whether the bundled length/2 fast path is applicable.
+  if (compactListLength(cursor) == null) {
+    while (isCons(cursor)) {
+      cursor = deref(cursor.args[1], env);
+    }
+    if (cursor.type === VAR) {
+      if (env._delays?.has(cursor.name)) return null;
+      if (length.type === VAR && cursor.name === length.name) return null;
+    }
   }
-  return prologueLengthSolutions(solver, goal, env);
+  return bundledLengthSolutions(solver, goal, env);
 }
 
-function* prologueLengthSolutions(solver, goal, env) {
+function* bundledLengthSolutions(solver, goal, env) {
   const requestedLength = deref(goal.args[1], env);
   if (requestedLength.type !== VAR) {
     if (requestedLength.type !== NUMBER || !isDecimalInteger(requestedLength.name)) {
@@ -798,6 +1163,11 @@ function* prologueLengthSolutions(solver, goal, env) {
 
 function* fixedLengthSolutions(solver, list, length, env) {
   let cursor = deref(list, env);
+  const compactLength = compactListLength(cursor);
+  if (compactLength != null) {
+    if (compactLength === length) yield env;
+    return;
+  }
   let remaining = length;
   let steps = 0n;
   while (isCons(cursor)) {
@@ -838,6 +1208,12 @@ function* fixedLengthSolutions(solver, list, length, env) {
 
 function* generatedLengthSolutions(solver, list, length, env) {
   let cursor = deref(list, env);
+  const compactLength = compactListLength(cursor);
+  if (compactLength != null) {
+    const next = bindGeneratedLength(solver, length, compactLength, env);
+    if (next != null) yield next;
+    return;
+  }
   let count = 0n;
   let steps = 0n;
   while (isCons(cursor)) {
@@ -908,13 +1284,352 @@ function pushFastPiFrames(stack, goal, rest, env, depth, active) {
 
 
 
-const SCALAR_FACT_RUN_FRAME_LIMIT = 100000;
+function fastGroundPureGoalTruth(solver, goal, env = new Env(), visiting = new Set()) {
+  if (!termIsGround(goal, env)) return null;
+  const resolved = copyResolved(goal, env);
+  if (resolved.type !== COMPOUND && resolved.type !== 'atom') return null;
+  const group = solver.program.findGroup(resolved.name, resolved.arity, resolved.module ?? 'user');
+  if (!group || group.hasCut || group.wfsDatalog) return null;
+
+  if (group.datalogLeastModel === true) {
+    const model = solver.datalogModelFor(group);
+    const relation = relationForDatalogGroup(model, group);
+    return relation?.has(resolved.args ?? []) ?? false;
+  }
+
+  if (group.scalarFactsOnly) {
+    const candidates = selectGroundClauseCandidates(group, resolved);
+    for (let index = 0; index < clauseCandidateLength(candidates); index++) {
+      const clause = clauseCandidateAt(candidates, index);
+      if (matchGroundClause(resolved, clause)?.done) return true;
+    }
+    return false;
+  }
+
+  if (group.recursive || group.tabled) return null;
+  const key = `${group.module}:${group.name}/${group.arity}`;
+  if (visiting.has(key)) return null;
+  const nextVisiting = new Set(visiting);
+  nextVisiting.add(key);
+
+  const candidates = selectGroundClauseCandidates(group, resolved);
+  for (let candidateIndex = 0; candidateIndex < clauseCandidateLength(candidates); candidateIndex++) {
+    const clause = clauseCandidateAt(candidates, candidateIndex);
+    const bindings = new Map();
+    let headMatches = true;
+    for (let i = 0; i < resolved.arity; i++) {
+      const pattern = clause.head.args[i];
+      const value = resolved.args[i];
+      if (pattern.type === 'var') {
+        const previous = bindings.get(pattern.name);
+        if (previous == null) bindings.set(pattern.name, value);
+        else if (!sameGroundTerm(previous, value)) { headMatches = false; break; }
+      } else if (isScalarTerm(pattern)) {
+        if (!sameScalarTerm(pattern, value)) { headMatches = false; break; }
+      } else {
+        return null;
+      }
+    }
+    if (!headMatches) continue;
+
+    let clauseTrue = true;
+    for (const body of clause.body) {
+      if (body.type !== COMPOUND && body.type !== 'atom') return null;
+      const args = [];
+      for (const arg of body.args ?? []) {
+        if (arg.type === 'var') {
+          const value = bindings.get(arg.name);
+          if (value == null) return null;
+          args.push(value);
+        } else if (isScalarTerm(arg)) {
+          args.push(arg);
+        } else {
+          return null;
+        }
+      }
+      const bodyGoal = body.type === 'atom' ? body : compound(body.name, args);
+      if (body.module != null) bodyGoal.module = body.module;
+      const truth = fastGroundPureGoalTruth(solver, bodyGoal, new Env(), nextVisiting);
+      if (truth == null) return null;
+      if (!truth) { clauseTrue = false; break; }
+    }
+    if (clauseTrue) return true;
+  }
+  return false;
+}
+
+function termReferencesResolvedVariable(term, variableName, env) {
+  const pending = [term];
+  const seen = new Set();
+  while (pending.length > 0) {
+    const value = derefForLocal(pending.pop(), env);
+    if (value.type === 'var') {
+      if (value.name === variableName) return true;
+      continue;
+    }
+    if (value.type !== COMPOUND || seen.has(value)) continue;
+    seen.add(value);
+    for (const arg of value.args) pending.push(arg);
+  }
+  return false;
+}
+
+function envHasObservableAliasTo(variableName, env) {
+  for (let state = env?._state; state != null; state = state.parent) {
+    if (state.bindingName != null && state.bindingName !== variableName &&
+        termReferencesResolvedVariable(state.bindingValue, variableName, env)) return true;
+    if (state.bindings) {
+      for (const [name, value] of state.bindings) {
+        if (name !== variableName && termReferencesResolvedVariable(value, variableName, env)) return true;
+      }
+    }
+  }
+  return false;
+}
+
+function* fusedFindallLengthSolutions(solver, innerGoal, countArg, env) {
+  const invoked = copyResolved(innerGoal, env);
+  if (invoked.type !== COMPOUND && invoked.type !== 'atom') return;
+  let count = fastCountPureGoal(solver, invoked, env);
+  if (count != null) {
+    // findall/3's existing collector intentionally carries a ten-million
+    // solution safety cap. Preserve that observable bound in the fused path.
+    if (count > 10000000n) count = 10000000n;
+  } else {
+    const child = solver.cloneForInnerGoal(10000000);
+    count = 0n;
+    try {
+      for (const _ of child.solve([invoked], env.clone(), 0)) count++;
+    } finally {
+      solver.absorbStatsFrom(child);
+    }
+  }
+  const next = env.clone();
+  if (unify(countArg, numberTerm(count), next)) yield next;
+}
+
+function findallLengthFusion(solver, goal, rest, env) {
+  if (goal.type !== COMPOUND || goal.name !== 'findall' || goal.arity !== 3 || rest.length === 0) return null;
+  const bag = derefForLocal(goal.args[2], env);
+  if (bag.type !== 'var') return null;
+
+  const lengthGoal = derefForLocal(rest[0], env);
+  if (lengthGoal.type !== COMPOUND || lengthGoal.name !== 'length' || lengthGoal.arity !== 2) return null;
+  const lengthGroup = solver.program.findGroup('length', 2, lengthGoal.module ?? 'user');
+  if (!lengthGroup || lengthGroup.bundledLibrary !== true ||
+      !['lists', 'prologue'].includes(lengthGroup.module)) return null;
+  const lengthList = derefForLocal(lengthGoal.args[0], env);
+  const countArg = derefForLocal(lengthGoal.args[1], env);
+  if (lengthList.type !== 'var' || lengthList.name !== bag.name || countArg.type !== 'var') return null;
+  if (envHasObservableAliasTo(bag.name, env)) return null;
+
+  // The bag may be elided only when no other part of the computation can
+  // observe it.  In particular, sharing it with Template or Goal changes
+  // findall/3's variable-scoping behavior and must stay on the ordinary path.
+  if (termReferencesResolvedVariable(goal.args[0], bag.name, env) ||
+      termReferencesResolvedVariable(goal.args[1], bag.name, env) ||
+      termReferencesResolvedVariable(lengthGoal.args[1], bag.name, env)) return null;
+  for (let i = 1; i < rest.length; i++) {
+    if (termReferencesResolvedVariable(rest[i], bag.name, env)) return null;
+  }
+
+  return {
+    iterator: fusedFindallLengthSolutions(solver, goal.args[1], lengthGoal.args[1], env),
+    rest: rest.slice(1),
+  };
+}
+
+function countPlanTermIsFlat(term) {
+  return term?.type === 'var' || isScalarTerm(term);
+}
+
+function expandPureCountGoal(solver, goal, callerModule, visiting, budget) {
+  if ((goal.type !== COMPOUND && goal.type !== 'atom') ||
+      !(goal.args ?? []).every(countPlanTermIsFlat)) return null;
+  const group = solver.program.findGroup(goal.name, goal.arity, goal.module ?? callerModule ?? 'user');
+  if (!group || group.hasCut || group.recursive || group.tabled || group.wfsDatalog || group.datalogLeastModel) return null;
+  if (group.scalarFactsOnly) return [{ equalities: [], leaves: [{ goal, group }] }];
+
+  const key = `${group.module}:${group.name}/${group.arity}`;
+  if (visiting.has(key)) return null;
+  const nextVisiting = new Set(visiting);
+  nextVisiting.add(key);
+  const out = [];
+
+  for (const clause of group.clauses) {
+    if (budget.remaining-- <= 0) return null;
+    const id = nextFreshId();
+    const variables = new Map();
+    const head = freshTerm(clause.head, `count${id}`, variables);
+    const body = clause.body.map((term) => freshTerm(term, `count${id}`, variables));
+    if (!(head.args ?? []).every(countPlanTermIsFlat)) return null;
+    let branches = [{
+      equalities: (goal.args ?? []).map((arg, index) => [arg, head.args[index]]),
+      leaves: [],
+    }];
+
+    for (const bodyGoal of body) {
+      const expanded = expandPureCountGoal(solver, bodyGoal, group.module, nextVisiting, budget);
+      if (expanded == null) return null;
+      const combined = [];
+      for (const left of branches) {
+        for (const right of expanded) {
+          combined.push({
+            equalities: [...left.equalities, ...right.equalities],
+            leaves: [...left.leaves, ...right.leaves],
+          });
+          if (combined.length > 4096) return null;
+        }
+      }
+      branches = combined;
+    }
+    out.push(...branches);
+    if (out.length > 4096) return null;
+  }
+  return out;
+}
+
+function countPlanDeref(term, env, bindings) {
+  let current = term;
+  const seen = new Set();
+  while (current?.type === 'var') {
+    if (seen.has(current.name)) break;
+    seen.add(current.name);
+    const local = bindings.get(current.name);
+    if (local !== undefined) {
+      current = local;
+      continue;
+    }
+    const outer = env.get(current.name);
+    if (outer !== undefined) {
+      current = outer;
+      continue;
+    }
+    break;
+  }
+  return current;
+}
+
+function countPlanUnify(left, right, env, bindings, trail) {
+  const a = countPlanDeref(left, env, bindings);
+  const b = countPlanDeref(right, env, bindings);
+  if (a.type === 'var') {
+    if (b.type === 'var' && a.name === b.name) return true;
+    bindings.set(a.name, b);
+    trail.push(a.name);
+    return true;
+  }
+  if (b.type === 'var') {
+    bindings.set(b.name, a);
+    trail.push(b.name);
+    return true;
+  }
+  return sameScalarTerm(a, b);
+}
+
+function undoCountBindings(bindings, trail, start) {
+  for (let i = trail.length - 1; i >= start; i--) bindings.delete(trail[i]);
+  trail.length = start;
+}
+
+function countLeafCandidateParts(leaf, env, bindings) {
+  const positions = [];
+  const values = [];
+  for (let i = 0; i < leaf.goal.arity; i++) {
+    const value = countPlanDeref(leaf.goal.args[i], env, bindings);
+    if (!isScalarTerm(value)) continue;
+    positions.push(i);
+    values.push(value);
+  }
+  return selectClauseCandidatesForValues(leaf.group, positions, values);
+}
+
+function countCandidateTotal(parts) {
+  return clauseCandidateLength(parts.primary) + clauseCandidateLength(parts.fallback);
+}
+
+function fastCountBranch(branch, env) {
+  const bindings = new Map();
+  const trail = [];
+  for (const [left, right] of branch.equalities) {
+    if (!countPlanUnify(left, right, env, bindings, trail)) return 0n;
+  }
+
+  let numberCount = 0;
+  let bigCount = null;
+  const increment = () => {
+    if (bigCount != null) {
+      bigCount++;
+    } else if (numberCount < Number.MAX_SAFE_INTEGER) {
+      numberCount++;
+    } else {
+      bigCount = BigInt(numberCount) + 1n;
+    }
+  };
+
+  const remaining = branch.leaves.map((_, index) => index);
+  const visit = (active) => {
+    if (active.length === 0) {
+      increment();
+      return;
+    }
+
+    let bestPosition = 0;
+    let bestParts = null;
+    let bestLength = Infinity;
+    for (let position = 0; position < active.length; position++) {
+      const leaf = branch.leaves[active[position]];
+      const parts = countLeafCandidateParts(leaf, env, bindings);
+      const length = countCandidateTotal(parts);
+      if (length < bestLength) {
+        bestLength = length;
+        bestPosition = position;
+        bestParts = parts;
+        if (length === 0) return;
+      }
+    }
+
+    const leafIndex = active[bestPosition];
+    const leaf = branch.leaves[leafIndex];
+    const nextActive = active.length === 1
+      ? []
+      : [...active.slice(0, bestPosition), ...active.slice(bestPosition + 1)];
+    for (const pass of [bestParts.primary, bestParts.fallback]) {
+      for (let candidateIndex = 0; candidateIndex < clauseCandidateLength(pass); candidateIndex++) {
+        const clause = clauseCandidateAt(pass, candidateIndex);
+        const start = trail.length;
+        let ok = true;
+        for (let i = 0; i < leaf.goal.arity; i++) {
+          if (!countPlanUnify(leaf.goal.args[i], clause.head.args[i], env, bindings, trail)) {
+            ok = false;
+            break;
+          }
+        }
+        if (ok) visit(nextActive);
+        undoCountBindings(bindings, trail, start);
+      }
+    }
+  };
+
+  visit(remaining);
+  return bigCount ?? BigInt(numberCount);
+}
+
+function fastCountPureGoal(solver, goal, env) {
+  if (solver.isoStrict || solver.solutionLimit !== Infinity || solver.maxInferences !== Infinity ||
+      env._clpz != null || (env._delays != null && env._delays.size !== 0)) return null;
+  const budget = { remaining: 8192 };
+  const branches = expandPureCountGoal(solver, goal, goal.module ?? 'user', new Set(), budget);
+  if (branches == null) return null;
+  let count = 0n;
+  for (const branch of branches) count += fastCountBranch(branch, env);
+  return count;
+}
 
 function tryPushScalarFactRunFrames(stack, solver, goals, env, depth, active) {
-  // Consecutive lookups into predicates that are entirely scalar ground facts
-  // are common in data-heavy joins. Execute such a prefix as one iterative join
-  // using local binding arrays, so intermediate fact candidates do not allocate
-  // cloned Env maps.
+  // Consecutive scalar-fact lookups are common in data-heavy joins.  Short
+  // joins are fastest when their continuation frames are materialized locally;
+  // wide joins can explode combinatorially, so they are streamed lazily.
   let runLength = 0;
   const groups = [];
   while (runLength < goals.length) {
@@ -930,10 +1645,16 @@ function tryPushScalarFactRunFrames(stack, solver, goals, env, depth, active) {
   }
   if (runLength < 2) return false;
 
+  const runGoals = goals.slice(0, runLength);
   const rest = goals.slice(runLength);
+  if (runLength >= 4) {
+    pushStreamingScalarFactRun(stack, solver, runGoals, groups, rest, env, depth, active);
+    return true;
+  }
+
   const localStack = [{ index: 0, names: [], values: [], depth }];
   const frames = [];
-
+  const frameLimit = 100000;
   while (localStack.length) {
     const state = localStack.pop();
     solver.stats.max_depth = Math.max(solver.stats.max_depth, state.depth);
@@ -941,11 +1662,17 @@ function tryPushScalarFactRunFrames(stack, solver, goals, env, depth, active) {
       const next = env.clone();
       for (let i = 0; i < state.names.length; i++) next.bind(state.names[i], state.values[i]);
       frames.push({ kind: 'goals', goals: rest, env: next, depth: state.depth, active });
-      if (frames.length > SCALAR_FACT_RUN_FRAME_LIMIT) return false;
+      if (frames.length > frameLimit) {
+        // Do not repeat the old bug of abandoning the optimization and then
+        // re-solving through the generic engine.  Restart this rare oversized
+        // short join as a streaming local join instead.
+        pushStreamingScalarFactRun(stack, solver, runGoals, groups, rest, env, depth, active);
+        return true;
+      }
       continue;
     }
 
-    const goal = goals[state.index];
+    const goal = runGoals[state.index];
     if (activeMightContain(goal, active) && activeVariantIn(goal, envWithLocal(env, state.names, state.values), active)) continue;
     solver.stats.solve_one_goal_calls++;
     const candidates = selectScalarFactCandidates(groups[state.index], goal, env, state.names, state.values);
@@ -967,6 +1694,57 @@ function tryPushScalarFactRunFrames(stack, solver, goals, env, depth, active) {
   return true;
 }
 
+function pushStreamingScalarFactRun(stack, solver, runGoals, groups, rest, env, depth, active) {
+  const iterator = scalarFactRunSolutions(solver, runGoals, groups, env, depth, active);
+  const first = iterator.next();
+  if (first.done) return;
+  stack.push({
+    kind: 'resumeBuiltin',
+    iterator,
+    goals: rest,
+    depth: depth + runGoals.length,
+    active,
+  });
+  stack.push({
+    kind: 'goals',
+    goals: rest,
+    env: first.value,
+    depth: depth + runGoals.length,
+    active,
+  });
+}
+
+function* scalarFactRunSolutions(solver, goals, groups, env, depth, active) {
+  const localStack = [{ index: 0, names: [], values: [] }];
+  while (localStack.length) {
+    const state = localStack.pop();
+    solver.stats.max_depth = Math.max(solver.stats.max_depth, depth + state.index);
+    if (state.index === goals.length) {
+      const next = env.clone();
+      for (let i = 0; i < state.names.length; i++) next.bind(state.names[i], state.values[i]);
+      yield next;
+      continue;
+    }
+
+    const goal = goals[state.index];
+    if (activeMightContain(goal, active) && activeVariantIn(goal, envWithLocal(env, state.names, state.values), active)) continue;
+    solver.stats.solve_one_goal_calls++;
+    const candidates = selectScalarFactCandidates(groups[state.index], goal, env, state.names, state.values);
+    const nextStates = [];
+    for (const pass of [candidates.primary, candidates.fallback]) {
+      for (let candidateIndex = 0; candidateIndex < clauseCandidateLength(pass); candidateIndex++) {
+        const clause = clauseCandidateAt(pass, candidateIndex);
+        const match = matchScalarFactLocal(goal, clause.head, env, state.names, state.values);
+        if (!match) continue;
+        solver.stats.unify_calls++;
+        nextStates.push({ index: state.index + 1, names: match.names, values: match.values });
+      }
+    }
+    for (let i = nextStates.length - 1; i >= 0; i--) localStack.push(nextStates[i]);
+    if (solver.solutionsSeen >= solver.solutionLimit) return;
+  }
+}
+
 
 function activeMightContain(goal, active) {
   if (active.length === 0 || goal.type !== COMPOUND) return false;
@@ -1146,6 +1924,65 @@ function tryPushCompactBinaryChainFrames(stack, solver, group, goal, rest, env,
   }
 }
 
+function tryPushGroundScalarRuleFrame(stack, solver, group, goal, rest, env, depth, active) {
+  // A fully-ground call to a single flat rule can be checked without freshening
+  // the rule or allocating an Env for every body literal.  This is especially
+  // valuable for data-validation joins such as rb(A,B,C,D,E) in ORB Join2.
+  if (!termIsGround(goal, env) || group.clauses.length !== 1) return false;
+  const clause = group.clauses[0];
+  if (clause?.compactBinary === true || clause.body.length < 2 || clause.head.type !== COMPOUND) return false;
+  if (clause.head.name !== goal.name || clause.head.arity !== goal.arity) return false;
+
+  const bindings = new Map();
+  const resolvedGoal = copyResolved(goal, env);
+  for (let i = 0; i < clause.head.arity; i++) {
+    const pattern = clause.head.args[i];
+    const value = resolvedGoal.args[i];
+    if (pattern.type === 'var') {
+      const previous = bindings.get(pattern.name);
+      if (previous == null) bindings.set(pattern.name, value);
+      else if (!sameGroundTerm(previous, value)) return true;
+    } else if (isScalarTerm(pattern)) {
+      if (!sameGroundTerm(pattern, value)) return true;
+    } else {
+      return false;
+    }
+  }
+
+  for (const body of clause.body) {
+    if (body.type !== COMPOUND) return false;
+    const args = [];
+    for (const arg of body.args) {
+      if (arg.type === 'var') {
+        const value = bindings.get(arg.name);
+        if (value == null) return false;
+        args.push(value);
+      } else if (isScalarTerm(arg)) {
+        args.push(arg);
+      } else {
+        return false;
+      }
+    }
+    const bodyGroup = solver.program.findGroup(body.name, body.arity, body.module ?? group.module);
+    if (!bodyGroup || bodyGroup.tabled || !bodyGroup.scalarFactsOnly) return false;
+    const bodyGoal = compound(body.name, args);
+    const candidates = selectGroundClauseCandidates(bodyGroup, bodyGoal);
+    let matches = 0;
+    for (let candidateIndex = 0; candidateIndex < clauseCandidateLength(candidates); candidateIndex++) {
+      const fact = clauseCandidateAt(candidates, candidateIndex);
+      const matched = matchGroundClause(bodyGoal, fact);
+      if (matched?.done) {
+        matches++;
+        if (matches > 1) return false; // Preserve duplicate-proof semantics.
+      }
+    }
+    if (matches === 0) return true;
+  }
+
+  stack.push({ kind: 'goals', goals: rest, env, depth: depth + 1, active });
+  return true;
+}
+
 function tryPushGroundChainFrames(stack, solver, group, goal, rest, env, depth, active) {
   if (tryPushCompactBinaryChainFrames(stack, solver, group, goal, rest, env, depth, active)) return true;
   // Compress deterministic ground single-goal chains such as deep taxonomy
@@ -1358,7 +2195,20 @@ function rememberMemoAnswer(entry, goal, env) {
   const key = answerKeys.join('\x1f');
   if (entry.answerKeys.has(key)) return;
   entry.answerKeys.add(key);
+  const answerIndex = entry.answers.length;
   entry.answers.push(answerArgs);
+  for (let position = 0; position < answerArgs.length; position++) {
+    const value = answerArgs[position];
+    const scalarKey = memoAnswerScalarKey(value);
+    if (scalarKey != null) {
+      const index = entry.answerIndexes[position];
+      let bucket = index.get(scalarKey);
+      if (bucket == null) index.set(scalarKey, bucket = []);
+      bucket.push(answerIndex);
+    } else if (value.type === 'var') {
+      entry.answerVariableFallbacks[position].push(answerIndex);
+    }
+  }
 }
 
 function activeVariantIn(goal, env, active) {
@@ -1490,19 +2340,13 @@ function derefForLocal(term, env) {
 function memoKey(goal, env, group = null) {
   const required = group?.tableInputPositions ?? [];
   const ground = goal.args.map((arg) => termIsGround(arg, env));
-  const hasBound = required.length > 0
+  const hasBound = group?.tableAllVariants === true || (required.length > 0
     ? required.some((index) => ground[index])
-    : ground.some(Boolean);
-  // Automatic tabling only admits calls with a ground input. Avoid building a
-  // potentially huge canonical key for the non-ground structural calls that
-  // will use the ordinary active-call guard instead.
+    : ground.some(Boolean));
   if (!hasBound) return { hasBound: false, text: '' };
 
   const variables = new Map();
-  const parts = goal.args.map((arg) => {
-    const value = derefForLocal(arg, env);
-    return value.type === 'var' ? '_' : canonicalTermKey(value, env, variables);
-  });
+  const parts = goal.args.map((arg) => canonicalTermKey(arg, env, variables));
   return { hasBound, text: parts.join('|') };
 }
 
@@ -1553,10 +2397,10 @@ function copyResolvedWithKey(term, env, variables) {
     return { term: termModuleCache.variable(value.name), key: `var:${id}` };
   }
   if (!value.args?.length) {
-    return {
-      term: new termModuleCache.Term(value.type, value.name, value.args),
-      key: `${value.type}:${value.name}`,
-    };
+    // Atomic terms are immutable in the solver.  Share them across table
+    // answers instead of allocating a fresh host object for every cell of a
+    // large closure such as tc/2.
+    return { term: value, key: `${value.type}:${value.name}` };
   }
   const children = value.args.map((arg) => copyResolvedWithKey(arg, env, variables));
   return {