eyeprolog 1.4.7 → 1.4.10

package/index.d.ts

@@ -27,6 +27,8 @@ export interface EyePrologRunOptions {
   isoStrict?: boolean;
   /** Autoload uniquely mapped predicates from the conservative interop profile. Defaults to true outside strict ISO mode. */
   autoload?: boolean;
+  /** Automatically table recursive user predicates in normal mode. Defaults to true; set false for traditional depth-first control. */
+  autoTabling?: boolean;
   /** Initial ISO interpretation of double-quoted list notation. Defaults to chars. */
   doubleQuotes?: 'chars' | 'codes' | 'atom';
   ioOptions?: {

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.4.7",
+  "version": "1.4.10",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",

package/src/cleanup.js

@@ -46,7 +46,7 @@ export function installCleanupLifecycle(Solver) {
       if (!completed) {
         let closeError = null;
         try {
-          closeOwnedSearchStacks(this, state, owner, thrown != null);
+          if (state.active) closeOwnedSearchStacks(this, state, owner, thrown != null);
         } catch (error) {
           closeError = error;
         }
@@ -71,6 +71,7 @@ function ensureLifecycleState(solver) {
   const state = {
     owner: null,
     stackOwners: new WeakMap(),
+    active: false,
   };
   Object.defineProperty(solver, cleanupLifecycleState, { value: state });
 
@@ -81,7 +82,7 @@ function ensureLifecycleState(solver) {
   solveStacks.push = function cleanupAwarePush(...stacks) {
     for (const stack of stacks) {
       state.stackOwners.set(stack, state.owner);
-      patchSearchStack(stack);
+      if (state.active) patchSearchStack(stack);
     }
     return originalPush.apply(this, stacks);
   };
@@ -92,8 +93,10 @@ function ensureLifecycleState(solver) {
     // unwinding an exception, a cleanup exception must not replace it. Normal
     // consumer pruning closes frames earlier in cleanupAwareSolve(), where
     // cleanup errors are allowed to propagate.
-    for (let index = removed.length - 1; index >= 0; index--) {
-      closeSearchStack(removed[index], true);
+    if (state.active) {
+      for (let index = removed.length - 1; index >= 0; index--) {
+        closeSearchStack(removed[index], true);
+      }
     }
     return removed;
   };
@@ -111,6 +114,17 @@ function withOwner(state, owner, operation) {
   }
 }
 
+function activateCleanupLifecycle(solver) {
+  const state = ensureLifecycleState(solver);
+  if (state.active) return state;
+  state.active = true;
+  for (const stack of solver.solveStacks) {
+    if (!state.stackOwners.has(stack)) state.stackOwners.set(stack, state.owner);
+    patchSearchStack(stack);
+  }
+  return state;
+}
+
 function patchSearchStack(stack) {
   if (stack[searchStackPatched]) return;
   Object.defineProperty(stack, searchStackPatched, { value: true });
@@ -189,11 +203,13 @@ function firstSetupSolution(solver, setup, env) {
 }
 
 function callCleanupBuiltin({ solver, goal, env }) {
+  activateCleanupLifecycle(solver);
   const cleanup = callableTerm(goal.args[1], env);
   return cleanupProtectedIterator(solver, goal.args[0], cleanup, env);
 }
 
 function setupCallCleanupBuiltin({ solver, goal, env }) {
+  activateCleanupLifecycle(solver);
   let protectedIterator = null;
   let pending = true;
   const iterator = (function* setupThenProtected() {

package/src/cli.js

@@ -30,6 +30,7 @@ export async function main(argv) {
     isoStrict: false,
     portable: false,
     autoload: true,
+    autoTabling: true,
     version: false,
     warnings: false,
     goals: [],
@@ -57,6 +58,8 @@ export async function main(argv) {
       options.portable = true;
     } else if (!endOptions && arg === '--no-autoload') {
       options.autoload = false;
+    } else if (!endOptions && arg === '--no-auto-table') {
+      options.autoTabling = false;
     } else if (!endOptions && (arg === '--version' || arg === '-v')) {
       options.version = true;
     } else if (!endOptions && (arg === '--warnings' || arg === '-w')) {
@@ -153,7 +156,9 @@ export async function main(argv) {
     sourceMetadata: options.proof || options.isoStrict,
     isoStrict: options.isoStrict,
     autoload: options.autoload,
+    autoTabling: options.autoTabling,
     autoloadGoals: options.goals,
+    onWarning: printSourceWarning,
   });
 
   const portabilityFailures = program.interopPortabilityWarnings ?? [];
@@ -204,7 +209,10 @@ async function runDefault(engine, program, options) {
   const solver = new engine.Solver(program, {
     registry,
     isoStrict: options.isoStrict,
-    ioOptions: { write: (text) => process.stdout.write(String(text)) },
+    ioOptions: {
+      write: (text) => process.stdout.write(String(text)),
+      errorWrite: (text) => process.stderr.write(String(text)),
+    },
   });
   program = solver.program;
   const goals = engine.normalizeGoals(options.goals, solver);
@@ -251,6 +259,7 @@ Options:
                         reject EyeProlog language extensions and disable automatic tabling.
   --portable            Enforce the EyeProlog/Trealla/Scryer interop profile.
   --no-autoload         Disable conservative interop predicate autoloading.
+  --no-auto-table       Use traditional depth-first control instead of automatic recursive tabling.
   -v, --version         Show the package version and exit.
   -w, --warnings        Print non-fatal portability warnings to stderr.
   -g, --goal goal       Solve goal and print its ground answers; may be repeated.
@@ -271,6 +280,13 @@ function readStdin() {
   });
 }
 
+
+function printSourceWarning(warning) {
+  if (warning.kind !== 'singleton') return;
+  process.stderr.write(`Warning: singleton: ${warning.name}, near ${warning.filename}:${warning.line}
+`);
+}
+
 function printWarnings(program) {
   for (const warning of program.interopPortabilityWarnings ?? []) {
     if (warning.kind === 'library') {

package/src/io.js

@@ -64,6 +64,12 @@ export class StreamManager {
     this.add({ id: 1, alias: 'user_output', mode: 'append', type: 'text',
       content: '', position: 0, path: '', reposition: false,
       eofAction: 'reset', standard: true, write: this.output, pastEnd: false });
+    // user_error is a conventional de-facto standard stream used by the
+    // portable Scryer/Trealla libraries. Keep it on a negative internal handle
+    // so the first user-opened ISO stream retains its historical id 2.
+    this.add({ id: -1, alias: 'user_error', mode: 'append', type: 'text',
+      content: '', position: 0, path: '', reposition: false,
+      eofAction: 'reset', standard: true, write: options.errorWrite ?? this.output, pastEnd: false });
     this.currentInput = 0;
     this.currentOutput = 1;
   }

package/src/iso.js

@@ -581,19 +581,85 @@ function isPartialList(list, env) {
   return cursor.type === VAR;
 }
 
+const freshCopyGroundCache = new WeakMap();
+
+function structurallyVariableFree(term) {
+  if (term?.type === VAR) return false;
+  if (term?.type !== COMPOUND) return true;
+  const known = freshCopyGroundCache.get(term);
+  if (known !== undefined) return known;
+
+  const pending = [{ term, visited: false }];
+  while (pending.length > 0) {
+    const frame = pending.pop();
+    const current = frame.term;
+    if (current?.type !== COMPOUND || freshCopyGroundCache.has(current)) continue;
+    if (!frame.visited) {
+      pending.push({ term: current, visited: true });
+      for (let index = current.args.length - 1; index >= 0; index--) {
+        const child = current.args[index];
+        if (child?.type === COMPOUND && !freshCopyGroundCache.has(child)) {
+          pending.push({ term: child, visited: false });
+        }
+      }
+      continue;
+    }
+    let ground = true;
+    for (const child of current.args) {
+      if (child?.type === VAR || (child?.type === COMPOUND && freshCopyGroundCache.get(child) !== true)) {
+        ground = false;
+        break;
+      }
+    }
+    freshCopyGroundCache.set(current, ground);
+  }
+  return freshCopyGroundCache.get(term) === true;
+}
+
 function freshCopy(term, env, variables = new Map(), id = ++isoFresh) {
-  term = deref(term, env);
-  if (term.type === VAR) {
-    if (!variables.has(term.name)) variables.set(term.name, variable(`__copy${id}_${variables.size}`));
-    return variables.get(term.name);
+  const copyNode = (source) => {
+    if (source.type === VAR) {
+      if (!variables.has(source.name)) variables.set(source.name, variable(`__copy${id}_${variables.size}`));
+      return variables.get(source.name);
+    }
+    if (source.type !== COMPOUND) return source;
+    // Ground terms are immutable in EyeProlog. Sharing them is observably
+    // equivalent to copying and avoids rebuilding large lists for assertz/1,
+    // copy_term/2, bagof/findall storage, and exception terms.
+    if (structurallyVariableFree(source)) return source;
+    const copied = compound(source.name, new Array(source.args.length));
+    // Module qualification is execution context, not logical variable state.
+    // Preserve it across copy_term/2 so meta-predicate closures keep the caller
+    // module they received before a library copies and later invokes them.
+    if (source.module != null) copied.module = source.module;
+    return copied;
+  };
+
+  const source = deref(term, env);
+  const root = copyNode(source);
+  if (source.type !== COMPOUND || source.args.length === 0) return root;
+
+  // copy_term/2 is routinely used on long lists and large machine states.
+  // Traverse iteratively so term depth is independent of the host call stack.
+  // The map also preserves rational-tree cycles when occurs_check is disabled.
+  const copies = new Map([[source, root]]);
+  const pending = [{ source, target: root }];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    for (let index = 0; index < current.source.args.length; index++) {
+      const childSource = deref(current.source.args[index], env);
+      let child = childSource.type === COMPOUND ? copies.get(childSource) : null;
+      if (child == null) {
+        child = copyNode(childSource);
+        if (childSource.type === COMPOUND && child !== childSource) {
+          copies.set(childSource, child);
+          if (childSource.args.length > 0) pending.push({ source: childSource, target: child });
+        }
+      }
+      current.target.args[index] = child;
+    }
   }
-  if (term.type !== COMPOUND) return term;
-  const copied = compound(term.name, term.args.map((arg) => freshCopy(arg, env, variables, id)));
-  // Module qualification is execution context, not logical variable state.
-  // Preserve it across copy_term/2 so meta-predicate closures keep the caller
-  // module they received before a library copies and later invokes them.
-  if (term.module != null) copied.module = term.module;
-  return copied;
+  return root;
 }
 function* copyTermBuiltin({ goal, env }) {
   const next = env.clone();
@@ -609,13 +675,15 @@ function* termVariablesBuiltin({ goal, env }) {
   }
   const found = [];
   const seen = new Set();
-  const visit = (term) => {
-    term = deref(term, env);
+  const pending = [goal.args[0]];
+  while (pending.length > 0) {
+    const term = deref(pending.pop(), env);
     if (term.type === VAR) {
       if (!seen.has(term.name)) { seen.add(term.name); found.push(term); }
-    } else for (const arg of term.args) visit(arg);
-  };
-  visit(goal.args[0]);
+      continue;
+    }
+    for (let index = term.args.length - 1; index >= 0; index--) pending.push(term.args[index]);
+  }
   const next = env.clone();
   if (unify(goal.args[1], listFromItems(found), next)) yield next;
 }

package/src/lib/iso_ext.pl

@@ -28,8 +28,7 @@ call_nth(Goal, Nth) :- eyeprolog__call_nth(Goal, Nth).
 countall(Goal, Count) :- eyeprolog__countall(Goal, Count).
 
 forall(Condition, Action) :-
-    findall(Action, Condition, Actions),
-    iso_ext__call_all(Actions).
+    \+ (Condition, \+ Action).
 
 succ(X, S) :-
     var(X), !,

package/src/lib/random.pl

@@ -1,12 +1,13 @@
 /** Reproducible pseudo-random values.
 
     random/3 is EyeProlog's explicit-state interface.  maybe/0,
-    random_integer/3, and set_random/1 are the common Scryer/Trealla library
-    interface; they use a non-backtrackable seed while retaining the same
-    Park-Miller generator.
+    random/1, random_integer/3, and set_random/1 are the mutable-seed library
+    interface used for compatibility. random/1 uses EyeProlog's private native
+    state step for hot-loop performance; random/3 remains the portable explicit-
+    state Park-Miller generator, and both retain the same sequence.
 */
 
-:- module(random, [maybe/0, random/3, random_integer/3, set_random/1]).
+:- module(random, [maybe/0, random/1, random/3, random_integer/3, set_random/1]).
 
 :- use_module(library(debug), [bb_global_get/2, bb_put/2]).
 :- use_module(library(error), [instantiation_error/1, type_error/3]).
@@ -14,6 +15,10 @@
 maybe :-
     random_integer(0, 2, 0).
 
+
+random(Value) :-
+    eyeprolog__random_value(Value).
+
 random_integer(Lower, Upper, R) :-
     ( var(Lower) -> instantiation_error(random_integer/3)
     ; var(Upper) -> instantiation_error(random_integer/3)

package/src/parser.js

@@ -246,6 +246,8 @@ class Parser {
     this.anonymous = 0;
     this.variables = new Map();
     this.sourceMetadata = options.sourceMetadata !== false;
+    this.onWarning = typeof options.onWarning === 'function' ? options.onWarning : null;
+    this.currentSourceTermLine = 1;
     this.strictIso = options.isoStrict === true;
     this.parserFlagState = options.parserFlagState ?? {
       doubleQuotes: options.doubleQuotes ?? 'chars',
@@ -1010,9 +1012,14 @@ class Parser {
   parseProgram(emit = null) {
     const clauses = emit ? null : [];
     let clauseNumber = 0;
-    const accept = emit ?? ((clause) => clauses.push(clause));
+    const rawAccept = emit ?? ((clause) => clauses.push(clause));
+    const accept = (item) => {
+      reportClauseSingletonWarnings(item, this.onWarning, this.filename, this.currentSourceTermLine);
+      rawAccept(item);
+    };
     while (this.token.type !== TOK.EOF) {
       const line = this.token.line;
+      this.currentSourceTermLine = line;
       // Prefix operator notation needs one program-level distinction so
       // a comma in `?- A, B.` remains inside the query rather than outside the
       // prefix term. Ordinary functional notation is parsed as a term and then
@@ -1226,6 +1233,29 @@ function listAtomNames(term) {
 }
 
 
+function collectClauseVariableOccurrences(term, counts) {
+  if (term == null) return;
+  if (term.type === 'var') {
+    counts.set(term.name, (counts.get(term.name) ?? 0) + 1);
+    return;
+  }
+  if (term.type === COMPOUND) {
+    for (const arg of term.args) collectClauseVariableOccurrences(arg, counts);
+  }
+}
+
+function reportClauseSingletonWarnings(clause, onWarning, filename, line) {
+  if (typeof onWarning !== 'function' || clause?.kind === 'quad') return;
+  const counts = new Map();
+  collectClauseVariableOccurrences(clause.head, counts);
+  for (const goal of clause.body ?? []) collectClauseVariableOccurrences(goal, counts);
+  for (const [name, count] of counts) {
+    if (count !== 1 || String(name).startsWith('_')) continue;
+    onWarning({ kind: 'singleton', name, filename: filename ?? '<input>', line });
+  }
+}
+
+
 export function parseClauses(source, options = {}) {
   const ownsParserFlagState = options.parserFlagState == null;
   const initialDoubleQuotes = options.doubleQuotes ?? 'chars';
@@ -1282,6 +1312,7 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
   const accept = emit ?? ((clause) => clauses.push(clause));
   let anonymous = 0;
   let chunk = '';
+  let chunkStartLine = 1;
 
   const cached = (cache, key, create) => {
     const existing = cache.get(key);
@@ -1466,12 +1497,42 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
     return -1;
   };
 
-  const emitFastBinaryRange = (text, start, end) => {
+  const reportFastBinarySingletonWarnings = (head, body, line) => {
+    if (typeof options.onWarning !== 'function') return;
+    const variables = [];
+    const add = (type, name) => {
+      if (type !== 'var' || String(name).startsWith('_')) return;
+      variables.push(name);
+    };
+    add(head.arg0Type, head.arg0Name);
+    add(head.arg1Type, head.arg1Name);
+    if (body != null) {
+      add(body.arg0Type, body.arg0Name);
+      add(body.arg1Type, body.arg1Name);
+    }
+    for (let i = 0; i < variables.length; i++) {
+      let count = 0;
+      for (let j = 0; j < variables.length; j++) {
+        if (variables[i] === variables[j]) count++;
+      }
+      if (count === 1) {
+        options.onWarning({
+          kind: 'singleton',
+          name: variables[i],
+          filename: options.filename ?? '<input>',
+          line,
+        });
+      }
+    }
+  };
+
+  const emitFastBinaryRange = (text, start, end, line) => {
     if (!emitBinary || start >= end || text.charCodeAt(end - 1) !== 46) return false;
     const termEnd = end - 1;
     const rule = findRuleInRange(text, start, termEnd);
     if (rule < 0) {
       if (!parseBinaryRawRange(text, start, termEnd, rawHead)) return false;
+      reportFastBinarySingletonWarnings(rawHead, null, line);
       emitBinary(rawHead.name,
         rawHead.arg0Type, rawHead.arg0Name, rawHead.arg1Type, rawHead.arg1Name,
         null, null, null, null, null);
@@ -1480,6 +1541,7 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
     if (findRuleInRange(text, rule + 2, termEnd) >= 0 ||
         !parseBinaryRawRange(text, start, rule, rawHead) ||
         !parseBinaryRawRange(text, rule + 2, termEnd, rawBody)) return false;
+    reportFastBinarySingletonWarnings(rawHead, rawBody, line);
     emitBinary(rawHead.name,
       rawHead.arg0Type, rawHead.arg0Name, rawHead.arg1Type, rawHead.arg1Name,
       rawBody.name, rawBody.arg0Type, rawBody.arg0Name, rawBody.arg1Type, rawBody.arg1Name);
@@ -1541,6 +1603,7 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
 
   const flush = () => {
     const text = chunk.trim();
+    const sourceLine = chunkStartLine;
     chunk = '';
     if (!text) return true;
     // Once a preparation-time char_conversion/2 mapping is active, every
@@ -1549,11 +1612,15 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
     // here would silently bypass Convc for otherwise simple clauses.
     const simple = preparationConversionActive() ? null : parseSimple(text);
     if (simple) {
+      reportClauseSingletonWarnings(simple, options.onWarning, options.filename ?? '<input>', sourceLine);
       accept(simple);
       return true;
     }
     try {
-      const parsed = new Parser(text, { ...options, sourceMetadata: false }).parseProgram();
+      const nestedWarning = typeof options.onWarning === 'function'
+        ? (warning) => options.onWarning({ ...warning, line: warning.line + sourceLine - 1 })
+        : null;
+      const parsed = new Parser(text, { ...options, sourceMetadata: false, onWarning: nestedWarning }).parseProgram();
       for (const clause of parsed) accept(clause);
       return true;
     } catch (_) {
@@ -1562,6 +1629,7 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
   };
 
   let lineStart = 0;
+  let lineNumber = 1;
   while (lineStart <= source.length) {
     let lineEnd = source.indexOf('\n', lineStart);
     if (lineEnd < 0) lineEnd = source.length;
@@ -1571,17 +1639,21 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
     [contentStart, contentEnd] = trimRange(source, contentStart, contentEnd);
     if (contentStart < contentEnd && source.charCodeAt(contentStart) !== 37) {
       if (!chunk && source.charCodeAt(contentEnd - 1) === 46 && !preparationConversionActive()) {
-        if (emitFastBinaryRange(source, contentStart, contentEnd)) {
+        if (emitFastBinaryRange(source, contentStart, contentEnd, lineNumber)) {
           // The program builder accepted a compact binary clause directly.
         } else {
           const simple = parseFastRange(source, contentStart, contentEnd);
-          if (simple) accept(simple);
-          else {
+          if (simple) {
+            reportClauseSingletonWarnings(simple, options.onWarning, options.filename ?? '<input>', lineNumber);
+            accept(simple);
+          } else {
+            chunkStartLine = lineNumber;
             chunk = source.slice(lineStart, lineEnd) + '\n';
             if (!flush()) return null;
           }
         }
       } else {
+        if (!chunk) chunkStartLine = lineNumber;
         chunk += source.slice(lineStart, lineEnd) + '\n';
         if (source.charCodeAt(contentEnd - 1) === 46) {
           if (!flush()) return null;
@@ -1590,6 +1662,7 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
     }
     if (lineEnd === source.length) break;
     lineStart = lineEnd + 1;
+    lineNumber++;
   }
   if (chunk.trim() && !flush()) return null;
   return clauses ?? true;

package/src/program-indexing.js

@@ -86,13 +86,24 @@ export function clauseHasCut(clause) {
 }
 
 export function termContainsCut(term) {
-  if (term.type === ATOM) return term.name === '!';
-  return term.type === COMPOUND && term.args.some(termContainsCut);
+  const pending = [term];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    if (current?.type === ATOM && current.name === '!') return true;
+    if (current?.type !== COMPOUND) continue;
+    for (let index = current.args.length - 1; index >= 0; index--) pending.push(current.args[index]);
+  }
+  return false;
 }
 
 export function termHasNoVariables(term) {
-  if (!term || term.type === 'var') return false;
-  return !term.args?.some((arg) => !termHasNoVariables(arg));
+  const pending = [term];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    if (!current || current.type === 'var') return false;
+    for (let index = current.args?.length - 1 ?? -1; index >= 0; index--) pending.push(current.args[index]);
+  }
+  return true;
 }
 
 // These defaults mirror SWI-Prolog's JITI admission policy: small predicates
@@ -110,7 +121,51 @@ export function makeArgumentIndex() {
     numberBuckets: new Map(),
     fallback: [],
     sawScalar: false,
+    // Dynamic predicates often store fully-ground structured keys such as
+    // seen(answer(...)). Keep an exact structural hash alongside the scalar
+    // indexes so repeated membership checks do not scan every prior clause.
+    groundBuckets: new Map(),
+    groundFallback: [],
+    sawGround: false,
+  };
+}
+
+function groundTermIndexKey(term, env = null) {
+  // Use a compact structural hash instead of materializing the complete term
+  // spelling as a Map key. Dynamic bookkeeping predicates frequently store
+  // long ground lists; a fixed-size hash avoids retaining another full copy of
+  // every list merely for indexing. Hash collisions are harmless because the
+  // selected clauses are still matched normally by the solver.
+  let hash = 0x811c9dc5;
+  const mixCode = (code) => { hash = Math.imul(hash ^ code, 0x01000193) >>> 0; };
+  const mixString = (text) => {
+    for (let index = 0; index < text.length; index++) mixCode(text.charCodeAt(index));
+    mixCode(0xff);
   };
+  const stack = [term];
+  while (stack.length > 0) {
+    const raw = stack.pop();
+    const current = env == null ? raw : deref(raw, env);
+    if (current?.type === VAR) return null;
+    if (current?.type === COMPOUND) {
+      mixCode(1);
+      mixString(current.name);
+      mixCode(current.arity);
+      for (let index = current.args.length - 1; index >= 0; index--) stack.push(current.args[index]);
+      continue;
+    }
+    if (current?.type === 'number') {
+      mixCode(2);
+      mixString(numberValueKey(current.name));
+    } else if (current?.type === 'string') {
+      mixCode(3);
+      mixString(String(current.name));
+    } else {
+      mixCode(4);
+      mixString(String(current?.name ?? ''));
+    }
+  }
+  return hash;
 }
 
 function scalarBuckets(index, term) {
@@ -168,7 +223,7 @@ export function indexCompactOne(index, type, name, clause, clauses = null, claus
   }
 }
 
-export function indexOne(index, arg, clause, clauses = null, clausePosition = -1) {
+export function indexOne(index, arg, clause, clauses = null, clausePosition = -1, indexGround = false) {
   if (isScalar(arg)) {
     if (!index.sawScalar) {
       index.sawScalar = true;
@@ -178,6 +233,18 @@ export function indexOne(index, arg, clause, clauses = null, clausePosition = -1
   } else if (index.sawScalar) {
     index.fallback.push(clause);
   }
+
+  if (!indexGround) return;
+  const groundKey = groundTermIndexKey(arg);
+  if (groundKey != null) {
+    if (!index.sawGround) {
+      index.sawGround = true;
+      if (clauses && clausePosition > 0) index.groundFallback = clauses.slice(0, clausePosition);
+    }
+    addClauseBucket(index.groundBuckets, groundKey, clause);
+  } else if (index.sawGround) {
+    index.groundFallback.push(clause);
+  }
 }
 
 function indexFallback(index, group) {
@@ -204,7 +271,9 @@ export function rebuildGroupIndexes(group) {
     clause.scalarHead = clause.head.type === COMPOUND && clause.head.args.every(isScalar);
     if (clauseHasCut(clause)) group.hasCut = true;
     if (clause.body.length !== 0 || !clause.scalarHead) group.scalarFactsOnly = false;
-    for (let i = 0; i < group.arity; i++) indexOne(group.argIndexes[i], clause.head.args[i], clause, group.clauses, clausePosition);
+    for (let i = 0; i < group.arity; i++) {
+      indexOne(group.argIndexes[i], clause.head.args[i], clause, group.clauses, clausePosition, group.dynamic === true);
+    }
   }
 }
 
@@ -301,15 +370,36 @@ export function selectClauseCandidates(group, goal, env) {
   }
   const positions = [];
   const values = [];
+  let bestGround = null;
+  let bestGroundLength = group.clauses.length;
   for (let i = 0; i < goal.arity; i++) {
     const arg = deref(goal.args[i], env);
-    if (!isScalar(arg)) continue;
-    positions.push(i);
-    values.push(arg);
+    if (isScalar(arg)) {
+      positions.push(i);
+      values.push(arg);
+      continue;
+    }
+    const index = group.argIndexes[i];
+    if (!index?.sawGround) continue;
+    const key = groundTermIndexKey(arg, env);
+    if (key == null) continue;
+    const primary = index.groundBuckets.get(key) ?? null;
+    const fallback = index.groundFallback;
+    const length = clauseCollectionLength(primary) + fallback.length;
+    if (length < bestGroundLength) {
+      bestGround = fallback.length === 0 ? (primary ?? [])
+        : clauseCollectionLength(primary) === 0 ? fallback
+          : mergeClausesInSourceOrder(primary, fallback);
+      bestGroundLength = length;
+    }
   }
-  if (positions.length === 0) return { primary: group.clauses, fallback: [] };
-
-  return selectClauseCandidatesForValues(group, positions, values);
+  const scalarParts = positions.length === 0 ? null : selectClauseCandidatesForValues(group, positions, values);
+  const scalarLength = scalarParts == null
+    ? group.clauses.length
+    : clauseCollectionLength(scalarParts.primary) + scalarParts.fallback.length;
+  if (bestGround != null && bestGroundLength < scalarLength) return { primary: bestGround, fallback: [] };
+  if (scalarParts != null) return scalarParts;
+  return { primary: group.clauses, fallback: [] };
 }
 
 // The scalar-fact join already has dereferenced local values. Keeping this