eyeprolog 1.2.8 → 1.2.9

package/package.json

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

package/src/solver.js

@@ -47,7 +47,10 @@ export class Solver {
     this.maxInferences = options.maxInferences ?? Infinity;
     this.inferences = 0;
     this.inferenceLimitExceeded = false;
-    this.solutionLimit = options.solutionLimit ?? 10000000;
+    // Do not impose an implicit answer cap. Infinite and very large searches are
+    // part of normal Prolog semantics; callers that need a resource bound can
+    // still supply solutionLimit explicitly.
+    this.solutionLimit = options.solutionLimit ?? Infinity;
     this.solutionsSeen = 0;
     this.prologFlags = options.prologFlags ?? defaultPrologFlags('error', this.isoStrict);
     if (this.isoStrict) {

package/test/run-regression.mjs

@@ -2063,6 +2063,21 @@ open(X) :- candidate(X), \\+ closed(X).
         assertEqual(answers.join('\n'), 'p(a)\np(b)', 'answers');
       },
     },
+    {
+      name: 'solver has no implicit solution limit',
+      run: () => {
+        const program = Program.parse('p(a).\n');
+        const solver = new Solver(program);
+        assertEqual(String(solver.solutionLimit), 'Infinity', 'default solution limit');
+        // Crossing the former 10,000,000-answer ceiling must not make an
+        // otherwise available answer disappear. This exercises the boundary
+        // without making the regression suite enumerate ten million answers.
+        solver.solutionsSeen = 10_000_000;
+        const goal = parseGoalText('p(X)');
+        const answers = [...solver.solve([goal], new Env(), 0)].map((env) => termToString(goal, env, true));
+        assertEqual(answers.join('\n'), 'p(a)', 'answer beyond former default ceiling');
+      },
+    },
     {
       name: 'solver honors solution limits',
       run: () => {

package/the-art-of-eyeprolog.md

@@ -1805,7 +1805,13 @@ const solver = new Solver(program, {
 ```
 
 The limits are safety ceilings, not logical declarations. Reaching one may
-truncate search; it does not prove that no further answer exists.
+truncate search; it does not prove that no further answer exists. At the `Solver`
+API boundary, `solutionLimit` is opt-in: if it is omitted, ordinary solving and
+child searches that inherit the solver limit do not stop after a fixed number of
+solutions. This matters for re-executable goals such as `repeat/0` and for
+library relations such as `call_nth/2`; an implementation safety threshold must
+not turn a still re-executable search into logical failure. Embedders that need
+a finite answer budget should pass `solutionLimit` explicitly.
 
 ### Implementation boundary