eyeprolog 1.2.8 → 1.2.10

package/package.json

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

package/src/explain.js

@@ -101,8 +101,9 @@ function* proveGoalAll(program, goal, env, depth, maxDepth, registry, active) {
     for (let candidateIndex = 0; candidateIndex < clauseCandidateLength(pass); candidateIndex++) {
       const clause = clauseCandidateAt(pass, candidateIndex);
       const id = nextFreshId();
-      const freshHead = freshTerm(clause.head, id);
-      const freshBody = clause.body.map((term) => freshTerm(term, id));
+      const freshVariables = new Map();
+      const freshHead = freshTerm(clause.head, id, freshVariables);
+      const freshBody = clause.body.map((term) => freshTerm(term, id, freshVariables));
       const next = env.clone();
       if (!unify(goal, freshHead, next)) continue;
 

package/src/parser.js

@@ -165,6 +165,7 @@ class Parser {
     this.pos = 0;
     this.line = 1;
     this.anonymous = 0;
+    this.variables = new Map();
     this.sourceMetadata = options.sourceMetadata !== false;
     this.strictIso = options.isoStrict === true;
     this.parserFlagState = options.parserFlagState ?? {
@@ -633,7 +634,12 @@ class Parser {
       const name = this.token.text;
       this.advance();
       if (name === '_') return variable(`__anon${this.anonymous++}`);
-      return variable(name);
+      let term = this.variables.get(name);
+      if (term == null) {
+        term = variable(name);
+        this.variables.set(name, term);
+      }
+      return term;
     }
     if (this.token.type === TOK.STRING) {
       const value = this.token.text;

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) {
@@ -395,6 +398,8 @@ export class Solver {
         break;
       }
       }
+    } catch (error) {
+      throw normalizeHostResourceError(error);
     } finally {
       const stackIndex = this.solveStacks.indexOf(registeredStack);
       if (stackIndex >= 0) this.solveStacks.splice(stackIndex, 1);
@@ -447,8 +452,9 @@ export class Solver {
         }
         if (headCannotMatch(goal, clause.head, env)) continue;
         const id = nextFreshId();
-        const freshHead = freshTerm(clause.head, id);
-        const freshBody = clause.body.map((term) => freshTerm(term, id));
+        const freshVariables = new Map();
+        const freshHead = freshTerm(clause.head, id, freshVariables);
+        const freshBody = clause.body.map((term) => freshTerm(term, id, freshVariables));
         const next = env.clone();
         this.stats.unify_calls++;
         if (!unify(goal, freshHead, next)) continue;
@@ -479,6 +485,19 @@ export class Solver {
 
 }
 
+function normalizeHostResourceError(error) {
+  if (error?.name !== 'RangeError') return error;
+  const message = String(error?.message ?? '');
+  // V8 reports exhausted Map/Set capacity as a host RangeError.  ISO 7.12.2 h
+  // requires processor resource exhaustion to surface as resource_error/1,
+  // with the resource atom implementation dependent.  EyeProlog uses the
+  // finite_memory spelling already accepted by its ISO conformance corpus.
+  if (/^(?:Map|Set) maximum size exceeded$/.test(message)) {
+    return new PrologError('resource_error(finite_memory)');
+  }
+  return error;
+}
+
 function qualifyMetaArguments(goal, group) {
   const callerModule = goal.module ?? 'user';
   for (const index of group.metaArgumentPositions ?? []) {
@@ -598,8 +617,9 @@ function pushUserGoalUncachedFrames(stack, solver, group, goal, rest, env, depth
       }
       if (headCannotMatch(goal, clause.head, env)) continue;
       const id = nextFreshId();
-      const freshHead = freshTerm(clause.head, id);
-      const freshBody = clause.body.map((term) => freshTerm(term, id));
+      const freshVariables = new Map();
+      const freshHead = freshTerm(clause.head, id, freshVariables);
+      const freshBody = clause.body.map((term) => freshTerm(term, id, freshVariables));
       const next = env.clone();
       solver.stats.unify_calls++;
       if (!unify(goal, freshHead, next)) continue;
@@ -1230,7 +1250,7 @@ function copyResolvedWithKey(term, env, variables) {
       id = variables.size;
       variables.set(value.name, id);
     }
-    return { term: termModuleCache.variable(value.name), key: `var:${id}` };
+    return { term: termModuleCache.variable(value.name, value.order), key: `var:${id}` };
   }
   if (!value.args?.length) {
     return {

package/src/term.js

@@ -6,8 +6,10 @@ export const STRING = 'string';
 export const NUMBER = 'number';
 export const COMPOUND = 'compound';
 const EMPTY_ARGS = Object.freeze([]);
+// Variable term order is carried by the variable objects themselves.  Do not
+// retain a process-global name registry: runtime clause freshening can create
+// an unbounded sequence of names in an otherwise constant-space computation.
 let variableOrder = 0;
-const variableOrders = new Map();
 
 export class Term {
   constructor(type, name, args = []) {
@@ -20,10 +22,9 @@ export class Term {
   }
 }
 
-export const variable = (name) => {
+export const variable = (name, order = null) => {
   const term = new Term(VAR, name, EMPTY_ARGS);
-  if (!variableOrders.has(term.name)) variableOrders.set(term.name, ++variableOrder);
-  term.order = variableOrders.get(term.name);
+  term.order = order ?? ++variableOrder;
   return term;
 };
 export const atom = (name) => new Term(ATOM, name, EMPTY_ARGS);
@@ -270,6 +271,7 @@ export function unify(left, right, env, options = {}) {
 }
 
 export function cloneTerm(term) {
+  if (term.type === VAR) return variable(term.name, term.order);
   const cloned = term.type === COMPOUND && term.arity === 0
     ? atom(term.name)
     : new Term(term.type, term.name, term.args.map(cloneTerm));
@@ -277,18 +279,25 @@ export function cloneTerm(term) {
   return cloned;
 }
 
-export function freshTerm(term, suffix) {
-  if (term.type === VAR) return variable(`${term.name}#${suffix}`);
+export function freshTerm(term, suffix, variables = new Map()) {
+  if (term.type === VAR) {
+    let fresh = variables.get(term.name);
+    if (fresh == null) {
+      fresh = variable(`${term.name}#${suffix}`);
+      variables.set(term.name, fresh);
+    }
+    return fresh;
+  }
   const fresh = term.type === COMPOUND && term.arity === 0
     ? atom(term.name)
-    : new Term(term.type, term.name, term.args.map((arg) => freshTerm(arg, suffix)));
+    : new Term(term.type, term.name, term.args.map((arg) => freshTerm(arg, suffix, variables)));
   if (term.module != null) fresh.module = term.module;
   return fresh;
 }
 
 export function copyResolved(term, env) {
   const resolved = deref(term, env);
-  if (resolved.type === VAR) return variable(resolved.name);
+  if (resolved.type === VAR) return variable(resolved.name, resolved.order);
   const copied = resolved.type === COMPOUND && resolved.arity === 0
     ? atom(resolved.name)
     : new Term(resolved.type, resolved.name, resolved.args.map((arg) => copyResolved(arg, env)));
@@ -517,9 +526,13 @@ export function compareTerms(left, right) {
     return compareNumberText(left.name, right.name);
   }
   if (left.type === VAR) {
+    if (left.name === right.name) return 0;
     const leftOrder = left.order ?? 0;
     const rightOrder = right.order ?? 0;
-    return leftOrder < rightOrder ? -1 : leftOrder > rightOrder ? 1 : 0;
+    if (leftOrder !== rightOrder) return leftOrder < rightOrder ? -1 : 1;
+    // Explicitly copied order values are permitted internally; keep the
+    // implementation-defined variable order total even in that case.
+    return left.name < right.name ? -1 : 1;
   }
   if (left.type === ATOM || left.type === STRING) return left.name < right.name ? -1 : left.name > right.name ? 1 : 0;
   if (left.arity !== right.arity) return left.arity < right.arity ? -1 : 1;

package/test/run-regression.mjs

@@ -2063,6 +2063,68 @@ 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: 'fresh-variable generation stays bounded under a small host heap',
+      run: () => {
+        const engineUrl = new URL('../src/index.js', import.meta.url).href;
+        const programText = 'p(X) :- repeat, q(X).\nq(_).\n';
+        const script = `
+          import { Program, Solver, Env, parseGoalText, getEyePrologRegistry } from ${JSON.stringify(engineUrl)};
+          const program = Program.parse(${JSON.stringify(programText)});
+          const solver = new Solver(program, { registry: getEyePrologRegistry() });
+          const goal = parseGoalText('p(X)');
+          let count = 0;
+          for (const _ of solver.solve([goal], new Env(), 0)) {
+            if (++count === 300000) break;
+          }
+          if (count !== 300000) throw new Error('unexpected answer count: ' + count);
+          process.stdout.write(String(count));
+        `;
+        const result = spawnSync(process.execPath, [
+          '--max-old-space-size=32',
+          '--input-type=module',
+          '--eval',
+          script,
+        ], { cwd: packageRoot, encoding: 'utf8', timeout: 30000 });
+        if (result.error) throw result.error;
+        assertEqual(result.status, 0, `bounded-heap child status; stderr=${result.stderr}`);
+        assertEqual(result.stdout, '300000', 'fresh-variable answer count');
+      },
+    },
+    {
+      name: 'host Map capacity errors become ISO resource errors',
+      run: () => {
+        const registry = new BuiltinRegistry();
+        registry.add('exhaust_map', 0, function* () {
+          throw new RangeError('Map maximum size exceeded');
+        });
+        const solver = new Solver(Program.parse(''), { registry });
+        const goal = parseGoalText('exhaust_map');
+        let caught = null;
+        try {
+          [...solver.solve([goal], new Env(), 0)];
+        } catch (error) {
+          caught = error;
+        }
+        assertEqual(caught?.name, 'PrologError', 'normalized error type');
+        assertEqual(caught?.formal, 'resource_error(finite_memory)', 'normalized resource error');
+      },
+    },
     {
       name: 'solver honors solution limits',
       run: () => {

package/the-art-of-eyeprolog.md

@@ -1805,7 +1805,16 @@ 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. Host capacity
+failures that V8 reports as `Map maximum size exceeded` or `Set maximum size
+exceeded` are normalized at the solver boundary to the ISO error
+`resource_error(finite_memory)` instead of leaking a JavaScript `RangeError`.
 
 ### Implementation boundary
 
@@ -5605,8 +5614,16 @@ nonterminals.
 For ISO terms, the standard term order is variables, numbers, atoms, then compounds;
 compound terms compare by arity, functor, and arguments. Within the numeric
 category, floats precede integers; floats compare by finite numeric value and
-integers compare exactly. Double-quoted Prolog source follows the
-`double_quotes` flag and never creates an extra host-only scalar category.
+integers compare exactly. ISO leaves the ordering of two distinct variables
+implementation dependent, subject to stability while a sorted list is being
+created. EyeProlog assigns a creation ordinal to each logical variable and
+carries that ordinal on the variable term itself; repeated occurrences share it
+within parsing or clause-freshening scope. It therefore does not keep a
+process-global table of every fresh variable name ever created, so long-running
+generators can create and discard fresh variables without growing an unrelated
+host `Map`. Double-quoted Prolog source
+follows the `double_quotes` flag and never creates an extra host-only scalar
+category.
 
 ### Term construction and inspection