eyeprolog 1.5.66 → 1.5.68

package/package.json

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

package/src/lib/si.pl

@@ -70,12 +70,7 @@ si__condition((A;B)) :- si__condition(A), si__condition(B).
 %  f(a) vs f(Y) and X vs 1 are genuinely undecided.
 compare_si(Order, A, B) :-
     si__require_order(Order),
-    (  A == B
-    -> Order = (=)
-    ;  si__order_decided(A, B)
-    -> compare(Order, A, B)
-    ;  throw(error(instantiation_error, [predicate-compare_si/3]))
-    ).
+    si__compare(Order, [A-B]).
 
 si__require_order(Order) :- var(Order), !.
 si__require_order(Order) :-
@@ -86,25 +81,38 @@ si__require_order(Order) :-
     ; throw(error(type_error(atom, Order), [predicate-compare_si/3]))
     ).
 
-%  Both arguments are known to be non-identical here.
-si__order_decided(A, B) :- ( var(A) ; var(B) ), !, fail.
-si__order_decided(A, B) :-
+% Keep pending argument pairs in a work list. Recursing inside an if-then-else
+% condition retains a child Solver per list cell; testing whole-tail identity
+% at each step also repeatedly scans the same suffix (issue #105).
+si__compare(=, []).
+si__compare(Order, [A-B|Pairs]) :-
+    si__compare_pair(A, B, Comparison, Pairs, Next),
+    si__compare_next(Comparison, Order, Next).
+
+si__compare_next(=, Order, Pairs) :- si__compare(Order, Pairs).
+si__compare_next(<, <, _).
+si__compare_next(>, >, _).
+
+si__compare_pair(A, B, =, Pairs, Pairs) :-
+    ( var(A) ; var(B) ), !,
+    ( A == B -> true
+    ; throw(error(instantiation_error, [predicate-compare_si/3])) ).
+si__compare_pair([A|As], [B|Bs], =, Pairs, [A-B,As-Bs|Pairs]) :- !.
+si__compare_pair(A, B, Comparison, Pairs, Next) :-
     compound(A), compound(B), !,
     functor(A, NameA, ArityA),
     functor(B, NameB, ArityB),
-    (  ArityA =\= ArityB -> true
-    ;  NameA \== NameB -> true
+    (  ArityA =\= ArityB -> compare(Comparison, ArityA, ArityB), Next = Pairs
+    ;  NameA \== NameB -> compare(Comparison, NameA, NameB), Next = Pairs
     ;  A =.. [_|ArgsA],
        B =.. [_|ArgsB],
-       si__args_decided(ArgsA, ArgsB)
-    ).
-%  Otherwise both are non-variables and at least one is atomic, so either the
-%  type order or the values themselves settle it and no instantiation can
-%  change the outcome.
-si__order_decided(_, _).
-
-si__args_decided([A|As], [B|Bs]) :-
-    (  A == B
-    -> si__args_decided(As, Bs)
-    ;  si__order_decided(A, B)
+       Comparison = (=),
+       si__prepend_pairs(ArgsA, ArgsB, Next, Pairs)
     ).
+si__compare_pair(A, _, >, Pairs, Pairs) :- compound(A), !.
+si__compare_pair(_, B, <, Pairs, Pairs) :- compound(B), !.
+si__compare_pair(A, B, Comparison, Pairs, Pairs) :- compare(Comparison, A, B).
+
+si__prepend_pairs([], [], Pairs, Pairs).
+si__prepend_pairs([A|As], [B|Bs], [A-B|Pairs], Tail) :-
+    si__prepend_pairs(As, Bs, Pairs, Tail).

package/src/program.js

@@ -320,7 +320,7 @@ export class Program {
         // Numeric closure modes are a widely implemented compatibility
         // extension. Keep their existing hidden lexical qualification while
         // reserving explicit Module:Goal wrapping for ISO Part 2 ':' modes.
-        modes.push({ index, kind: 'closure' });
+        modes.push({ index, kind: 'closure', extraArguments: Number(spec.name) });
       }
     }
     const definitions = this.moduleMetaPredicates.get(module) ?? new Map();
@@ -1179,6 +1179,12 @@ function collectAutoloadGoalDependencies(goal, out = []) {
     return out;
   }
   if (goal?.type !== COMPOUND) return out;
+  if (goal.name === ':' && goal.arity === 2 && goal.args[0]?.type === ATOM) {
+    const start = out.length;
+    collectAutoloadGoalDependencies(goal.args[1], out);
+    for (let i = start; i < out.length; i++) out[i].module ??= goal.args[0].name;
+    return out;
+  }
   if (goal.name === ',' && goal.arity === 2) {
     collectAutoloadGoalDependencies(goal.args[0], out);
     collectAutoloadGoalDependencies(goal.args[1], out);
@@ -1198,7 +1204,7 @@ function collectAutoloadGoalDependencies(goal, out = []) {
     return out;
   }
 
-  out.push({ key: `${goal.name}/${goal.arity}`, name: goal.name, arity: goal.arity, module: goal.module });
+  out.push({ key: `${goal.name}/${goal.arity}`, name: goal.name, arity: goal.arity, module: goal.module, goal });
 
   if (goal.name === 'forall' && goal.arity === 2) {
     collectAutoloadGoalDependencies(goal.args[0], out);
@@ -1219,12 +1225,50 @@ function collectAutoloadGoalDependencies(goal, out = []) {
     collectAutoloadGoalDependencies(goal.args[2], out);
   } else if ((goal.name === 'call_cleanup' || goal.name === 'setup_call_cleanup') && (goal.arity === 2 || goal.arity === 3)) {
     for (const arg of goal.args) collectAutoloadGoalDependencies(arg, out);
-  } else if ((goal.name === 'call' || goal.name === 'time') && goal.arity === 1) {
-    collectAutoloadGoalDependencies(goal.args[0], out);
+  } else if (goal.name === 'call' && goal.arity >= 1) {
+    collectAutoloadClosureDependencies(goal.args[0], goal.arity - 1, out, goal.module);
   }
   return out;
 }
 
+function collectAutoloadClosureDependencies(closure, extraArguments, out, module) {
+  if (closure?.type === COMPOUND && closure.name === ':' && closure.arity === 2 && closure.args[0]?.type === ATOM) {
+    collectAutoloadClosureDependencies(closure.args[1], extraArguments, out, closure.args[0].name);
+    return;
+  }
+  if (closure?.type !== ATOM && closure?.type !== COMPOUND) return;
+  const start = out.length;
+  if (extraArguments === 0) {
+    collectAutoloadGoalDependencies(closure, out);
+  } else {
+    const arity = closure.arity + extraArguments;
+    // Extra closure arguments are unknown here. Record the final indicator
+    // without allocating placeholder terms or treating data arguments as goals.
+    out.push({ key: `${closure.name}/${arity}`, name: closure.name, arity, module: closure.module, goal: closure });
+  }
+  for (let i = start; i < out.length; i++) out[i].module ??= module;
+}
+
+function expandAutoloadMetaDependencies(program, dependencies, module = 'user') {
+  const seen = new WeakMap();
+  for (let i = 0; i < dependencies.length; i++) {
+    const dependency = dependencies[i];
+    if (dependency.goal == null) continue;
+    const caller = dependency.module ?? module;
+    const visitKey = `${caller}\u0000${dependency.key}`;
+    const visits = seen.get(dependency.goal) ?? new Set();
+    if (visits.has(visitKey)) continue;
+    visits.add(visitKey);
+    seen.set(dependency.goal, visits);
+    const group = program.findGroup(dependency.name, dependency.arity, caller);
+    for (const mode of group?.metaArgumentModes ?? []) {
+      if (mode.kind !== 'closure' || !Number.isSafeInteger(mode.extraArguments) || mode.extraArguments < 0) continue;
+      collectAutoloadClosureDependencies(dependency.goal?.args[mode.index], mode.extraArguments, dependencies, caller);
+    }
+  }
+  return dependencies;
+}
+
 function groupAutoloadDependencies(group) {
   const dependencies = [];
   for (const clause of group.clauses) {
@@ -1288,7 +1332,7 @@ function libraryAutoloadRequests(program, extraGoals = []) {
   const requests = new Map();
   for (const group of program.groups.values()) {
     if (bundledLibraryModule(program, group.module)) continue;
-    for (const dependency of groupAutoloadDependencies(group)) {
+    for (const dependency of expandAutoloadMetaDependencies(program, groupAutoloadDependencies(group), group.module)) {
       const targetModule = dependency.module ?? group.module;
       if (procedureResolvedBeforeAutoload(program, dependency, targetModule)) continue;
       const library = autoloadLibraryFor(dependency);
@@ -1304,7 +1348,7 @@ function libraryAutoloadRequests(program, extraGoals = []) {
     }
   }
   for (const goal of program.initializations) {
-    for (const dependency of collectAutoloadGoalDependencies(goal)) {
+    for (const dependency of expandAutoloadMetaDependencies(program, collectAutoloadGoalDependencies(goal))) {
       const targetModule = dependency.module ?? 'user';
       if (procedureResolvedBeforeAutoload(program, dependency, targetModule)) continue;
       const library = autoloadLibraryFor(dependency);
@@ -1319,7 +1363,7 @@ function libraryAutoloadRequests(program, extraGoals = []) {
       });
     }
   }
-  for (const dependency of extraGoalDependencies(extraGoals)) {
+  for (const dependency of expandAutoloadMetaDependencies(program, extraGoalDependencies(extraGoals))) {
     const targetModule = dependency.module ?? 'user';
     if (procedureResolvedBeforeAutoload(program, dependency, targetModule)) continue;
     const library = autoloadLibraryFor(dependency);

package/src/solver.js

@@ -1,7 +1,7 @@
 // Depth-first EyeProlog solver with builtin dispatch, memoization, and guarded recursion handling.
 // Most semantic decisions still flow through unification; optimizations only select candidates earlier.
 import {
-  ATOM, COMPOUND, NUMBER, STRING, VAR, Env, Term, atom, compactListLength, compactVariableList, compound, cons, copyResolved, deref, emptyList,
+  ATOM, COMPOUND, NUMBER, STRING, VAR, Env, Term, atom, compareTerms, compactListLength, compactVariableList, compound, cons, copyResolved, deref, emptyList,
   flattenConjunction, freshTerm, isCons, isDecimalInteger, isEmptyList, isScalar,
   numberTerm, numberTextFromDouble, properListItems, termIsGround, termToString, unify, variable, variantTerms,
 } from './term.js';
@@ -838,6 +838,16 @@ export class Solver {
           continue;
         }
 
+        const comparisonIterator = bundledCompareSiIterator(this, group, goal, env);
+        if (comparisonIterator != null) {
+          const firstResult = comparisonIterator.next();
+          if (firstResult.done) break;
+          goals = rest;
+          env = firstResult.value;
+          depth++;
+          continue;
+        }
+
         const lengthIterator = bundledLengthIterator(this, group, goal, env);
         if (lengthIterator != null) {
           const firstResult = lengthIterator.next();
@@ -1778,6 +1788,60 @@ function pushWfsAnswerFrames(stack, model, group, goal, rest, env, depth, active
   }
 }
 
+// Like the bundled length/member specializations, this keeps the portable
+// Prolog definition available to other registries and user definitions. A
+// direct walk avoids allocating fresh clause variables and doing occurs checks
+// over the remaining list suffix on each comparison step (issue #105).
+function bundledCompareSiIterator(solver, group, goal, env) {
+  if (solver.registry.eyePrologLibrary !== true || group.bundledLibrary !== true ||
+      group.module !== 'si' || group.name !== 'compare_si' || group.arity !== 3 ||
+      group.tabled || group.clauses.length !== 1) return null;
+  return bundledCompareSiSolutions(solver, goal, env);
+}
+
+const compareSiErrorContext = {};
+function* bundledCompareSiSolutions(solver, goal, env) {
+  try {
+    const order = deref(goal.args[0], env);
+    if (order.type !== VAR) {
+      if (order.type !== ATOM) throw new PrologError('type_error(atom)', order);
+      if (!['<', '=', '>'].includes(order.name)) throw new PrologError('domain_error(order)', order);
+    }
+    const pending = [goal.args[1], goal.args[2]];
+    let comparison = 0;
+    while (pending.length !== 0) {
+      const right = deref(pending.pop(), env);
+      const left = deref(pending.pop(), env);
+      if (left === right) continue;
+      if (left.type === VAR || right.type === VAR) {
+        if (left.type === VAR && right.type === VAR && left.name === right.name) continue;
+        throw new PrologError('instantiation_error');
+      }
+      if (left.type === COMPOUND && right.type === COMPOUND) {
+        if (left.arity !== right.arity) {
+          comparison = left.arity < right.arity ? -1 : 1;
+        } else if (left.name !== right.name) {
+          comparison = compareTerms(atom(left.name), atom(right.name));
+        } else {
+          // Push right-to-left so the first differing argument decides the
+          // result. Later variables must not cause premature errors.
+          for (let i = left.arity - 1; i >= 0; i--) pending.push(left.args[i], right.args[i]);
+          continue;
+        }
+      } else {
+        // At least one operand is atomic: type/value order is already fixed.
+        comparison = compareTerms(left, right);
+      }
+      if (comparison !== 0) break;
+    }
+    const next = env.clone();
+    solver.stats.unify_calls++;
+    if (unify(goal.args[0], atom(comparison < 0 ? '<' : comparison > 0 ? '>' : '='), next)) yield next;
+  } catch (error) {
+    throw attachBuiltinErrorContext(error, compareSiErrorContext, goal);
+  }
+}
+
 function bundledBetweenIterator(solver, group, goal, env) {
   if (solver.registry.eyePrologLibrary !== true ||
       group.module !== 'between' || group.name !== 'between' || group.arity !== 3 ||

package/src/term.js

@@ -1586,29 +1586,34 @@ const TYPE_ORDER = { [VAR]: 0, [NUMBER]: 1, [ATOM]: 2, [STRING]: 3, [COMPOUND]:
 const EMPTY_ENV = new Env();
 
 function compareTermsWithRanks(left, right, variableRanks) {
-  left = deref(left, EMPTY_ENV);
-  right = deref(right, EMPTY_ENV);
-  const lr = TYPE_ORDER[left.type] ?? 0;
-  const rr = TYPE_ORDER[right.type] ?? 0;
-  if (lr !== rr) return lr < rr ? -1 : 1;
-  if (left.type === NUMBER) {
-    const leftInteger = isDecimalInteger(left.name);
-    const rightInteger = isDecimalInteger(right.name);
-    if (leftInteger !== rightInteger) return leftInteger ? 1 : -1;
-    return compareNumberText(left.name, right.name);
-  }
-  if (left.type === VAR) {
-    if (left.name === right.name) return 0;
-    const leftOrder = variableRank(left.name, variableRanks);
-    const rightOrder = variableRank(right.name, variableRanks);
-    return leftOrder < rightOrder ? -1 : 1;
-  }
-  if (left.type === ATOM || left.type === STRING) return compareCharacterText(left.name, right.name);
-  if (left.arity !== right.arity) return left.arity < right.arity ? -1 : 1;
-  if (left.name !== right.name) return compareCharacterText(left.name, right.name);
-  for (let i = 0; i < left.arity; i++) {
-    const cmp = compareTermsWithRanks(left.args[i], right.args[i], variableRanks);
-    if (cmp) return cmp;
+  // Standard compare/3 is used alongside compare_si/3 in issue #105. Walk
+  // argument pairs explicitly so long lists do not exhaust the host stack.
+  const pending = [left, right];
+  while (pending.length !== 0) {
+    right = deref(pending.pop(), EMPTY_ENV);
+    left = deref(pending.pop(), EMPTY_ENV);
+    const lr = TYPE_ORDER[left.type] ?? 0;
+    const rr = TYPE_ORDER[right.type] ?? 0;
+    if (lr !== rr) return lr < rr ? -1 : 1;
+    if (left.type === NUMBER) {
+      const leftInteger = isDecimalInteger(left.name);
+      const rightInteger = isDecimalInteger(right.name);
+      if (leftInteger !== rightInteger) return leftInteger ? 1 : -1;
+      const cmp = compareNumberText(left.name, right.name);
+      if (cmp) return cmp;
+    } else if (left.type === VAR) {
+      if (left.name === right.name) continue;
+      const leftOrder = variableRank(left.name, variableRanks);
+      const rightOrder = variableRank(right.name, variableRanks);
+      return leftOrder < rightOrder ? -1 : 1;
+    } else if (left.type === ATOM || left.type === STRING) {
+      const cmp = compareCharacterText(left.name, right.name);
+      if (cmp) return cmp;
+    } else {
+      if (left.arity !== right.arity) return left.arity < right.arity ? -1 : 1;
+      if (left.name !== right.name) return compareCharacterText(left.name, right.name);
+      for (let i = left.arity - 1; i >= 0; i--) pending.push(left.args[i], right.args[i]);
+    }
   }
   return 0;
 }

package/test/regression/cases-regression.mjs

@@ -28,6 +28,142 @@ import {
 
 export function regressionCases() {
   return [
+    {
+      name: 'autoload follows declared meta-predicates and closure arities (issue #105)',
+      run: () => {
+        const wrappers = ':- meta_predicate(mytime(0)).\nmytime(G) :- time(G).\n' +
+          ':- meta_predicate(apply_one(1,?)).\napply_one(G,X) :- call(G,X).\n';
+        for (const goal of ['mytime(mytime(compare_si(<,a,b)))',
+          'apply_one(compare_si(<,a),b)', 'call(compare_si(<),a,b)', 'time(compare_si(<,a,b))']) {
+          const result = runEyeProlog(wrappers, { goals: [goal] });
+          assertIncludes(result.stdout, goal.startsWith('apply_one') ? 'apply_one' : goal.split('(')[0], goal);
+        }
+        const initialized = runEyeProlog(wrappers + ':- initialization((mytime(compare_si(<,a,b)),write(ok))).', { goals: [] });
+        assertIncludes(initialized.stdout, 'ok', 'initialization meta-goal');
+        // A predicate with the same name as a library wrapper can take data.
+        const data = Program.parse('time(_). answer :- time(compare_si(O,a,b)).');
+        assertEqual(data.autoloadedPredicates.some(({ indicator }) => indicator === 'compare_si/3'), false, 'data argument is not a goal');
+      },
+    },
+    {
+      name: 'imported user meta-wrappers autoload caller goals on the first REPL invocation',
+      run: () => {
+        const file = path.join(temp.dir, 'mytime.pl');
+        fs.writeFileSync(file, ':- module(timing_wrapper,[mytime/1]).\n:- meta_predicate(mytime(0)).\nmytime(G) :- time(G).\n');
+        const source = `:- use_module(${sourceAtom(file)}).\nanswer(ok) :- mytime(compare_si(<,a,b)).\n`;
+        assertIncludes(runEyeProlog(source, { goals: ['answer(X)'] }).stdout, 'answer(ok)', 'imported wrapper');
+        const repl = runCli([], { input: `use_module(${sourceAtom(file)}).\nmytime(compare_si(O,a,b)).\n.\nhalt.\n` });
+        assertEqual(repl.status, 0, repl.stderr);
+        assertIncludes(repl.stdout, 'O = (<)', 'first meta-call');
+        assertNotIncludes(repl.stdout + repl.stderr, 'existence_error', 'meta autoload');
+      },
+    },
+    {
+      name: 'bundled compare_si/3 matches the portable definition and respects user definitions',
+      run: () => {
+        const terms = ['X', 'Y', '1', '1.0', '-2', 'a', 'b', '[]', '[X,a]', '[X|Y]',
+          'f(X)', 'f(Y)', 'g(X)', 'f(X,a)', 'f(X,b)', 'f(g(X),a)'];
+        const clauses = [];
+        for (const left of terms) for (const right of terms) {
+          clauses.push(`answer(${clauses.length},R) :- catch((compare_si(O,${left},${right})->R=O;R=failed),error(E,C),R=error(E,C)).`);
+        }
+        const source = clauses.join('\n');
+        const optimized = runEyeProlog(source, { goals: ['answer(I,R)'] });
+        const portable = runEyeProlog(source, { goals: ['answer(I,R)'], registry: createDefaultRegistry() });
+        assertEqual(optimized.stdout, portable.stdout, 'all scalar, variable, compound and list comparisons');
+        const custom = runEyeProlog('compare_si(custom,_,_).', { goals: ['compare_si(O,a,b)'] });
+        assertIncludes(custom.stdout, 'compare_si(custom, a, b)', 'user definition');
+      },
+    },
+    {
+      name: 'compare/3 and compare_si/3 compare large lists and deep terms with a bounded host stack',
+      run: () => {
+        // A separate process bounds regressions in both memory and time. Build
+        // the operands directly so this measures comparison, not append/3.
+        const script = `
+          import {Program,Solver,Env,getEyePrologRegistry,variable,atom,compound,listFromItems,termToString} from './src/index.js';
+          const program = Program.parse(':- use_module(library(si)).');
+          const solver = new Solver(program,{registry:getEyePrologRegistry()});
+          function check(a,b,expected) {
+            for(const name of ['compare','compare_si']) {
+              const order=variable('Order');
+              const answers=[...solver.solve([compound(name,[order,a,b])],new Env(),0)];
+              if (answers.length!==1 || termToString(order,answers[0])!==expected) throw new Error(name+': wrong order');
+            }
+          }
+          for (const n of [16384,65536]) {
+            const prefix=Array.from({length:n},(_,i)=>variable('X'+i));
+            const a=listFromItems([...prefix,atom('a')]);
+            const b=listFromItems([...prefix,atom('b')]);
+            check(a,b,'<'); check(b,a,'>');
+            check(a,listFromItems([...prefix,atom('a')]),'=');
+          }
+          let a=atom('a'), b=atom('b');
+          for(let i=0;i<16384;i++) {a=compound('f',[a]);b=compound('f',[b]);}
+          check(a,b,'<');
+          console.log('ok');
+        `;
+        const result = spawnSync(process.execPath, ['--max-old-space-size=128', '--stack-size=256', '--input-type=module', '--eval', script], {
+          cwd: packageRoot, encoding: 'utf8', timeout: 15000,
+        });
+        if (result.error) throw result.error;
+        assertEqual(result.status, 0, `large comparison: ${result.stderr}`);
+        assertIncludes(result.stdout, 'ok', 'large comparison completes');
+      },
+    },
+    {
+      name: 'REPL prints the complete 8192-cell timed comparison answer (issue #105)',
+      run: () => {
+        const result = runCli([], { input:
+          'length(_,I),I=13,N is 2^I,length(P,N),append(P,[1],L1),append(P,[2],L2),' +
+          'time(compare(R,L1,L2)),time(compare_si(S,L1,L2)).\n.\nhalt.\n',
+          timeout: 60000,
+        });
+        if (result.error) throw result.error;
+        assertEqual(result.status, 0, result.stderr);
+        assertNotIncludes(result.stdout + result.stderr, 'Maximum call stack', 'host stack');
+        assertIncludes(result.stdout, 'I = 13, N = 8192', 'large answer');
+        assertIncludes(result.stdout, 'R = (<), S = (<)', 'both comparison results');
+      },
+    },
+    {
+      name: 'timed compare_si/3 backtracks over growing prefixes without exhausting the host stack (issue #105)',
+      run: () => {
+        // Bound the reported generator so the regression exhausts every
+        // answer, including sizes beyond the original 256-cell failure.
+        const result = runCli(['-'], { input:
+          '%% goal: answer(I,R,S)\n' +
+          'answer(I,R,S) :- length(_,I), (I =< 9 -> true ; !, fail), ' +
+          'N is 2^I, length(P,N), append(P,[1],L1), append(P,[2],L2), ' +
+          'time(compare(R,L1,L2)), time(compare_si(S,L1,L2)).\n',
+          timeout: 20000,
+        });
+        assertEqual(result.status, 0, `exit status; error=${result.error}; stderr=${result.stderr}`);
+        for (let i = 0; i <= 9; i++) {
+          assertIncludes(result.stdout, `answer(${i}, <, <).`, 'comparison result');
+        }
+        assertNotIncludes(result.stderr + result.stdout, 'Maximum call stack', 'host stack');
+      },
+    },
+    {
+      name: 'compare_si/3 work list preserves argument priority and instantiation errors',
+      run: () => {
+        const goals = [
+          'compare_si(=,f(X,g(Y)),f(X,g(Y))),var(X),var(Y)',
+          'compare_si(<,f(g(X),a),f(g(X),b)),var(X)',
+          'compare_si(>,f(g(b),a),f(g(a),z))',
+          'compare_si(<,[a|X],[b|Y]),var(X),var(Y)',
+          'compare_si(>,f(X),a),var(X)',
+          'compare_si(<,a,f(X)),var(X)',
+          '\\+ compare_si(>,f(g(X),a),f(g(X),b))',
+          'catch((compare_si(_,f(g(X),a),f(g(Y),b)),fail),error(instantiation_error,[predicate-compare_si/3]),true),var(X),var(Y)',
+        ];
+        for (const goal of goals) {
+          const result = runEyeProlog(`answer(ok) :- ${goal}.`, { goals: ['answer(X)'] });
+          assertIncludes(result.stdout, 'answer(ok)', goal);
+        }
+      },
+    },
     {
       name: 'compare_si/3 validates Order before term instantiation (issue #100)',
       run: () => {