eyeprolog 1.3.33 → 1.3.34

package/package.json

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

package/src/iso.js

@@ -1939,7 +1939,13 @@ function validateControlCallable(term, culprit, env) {
     if (current.type !== COMPOUND || ![',', ';', '->'].includes(current.name) || current.arity !== 2) continue;
     for (let index = current.arity - 1; index >= 0; index--) {
       const argument = deref(current.args[index], env);
-      if (argument.type === VAR) throw new PrologError('instantiation_error');
+      // A variable nested in a control construct is not an error at call/1
+      // entry: an earlier goal may instantiate it before execution reaches
+      // that position. If it is still unbound when selected, the solver then
+      // raises instantiation_error at that point, after any preceding effects.
+      // Non-variable non-callables are different: ISO call/1 validates those
+      // eagerly and reports the whole control term as the culprit.
+      if (argument.type === VAR) continue;
       if (argument.type !== ATOM && argument.type !== COMPOUND) {
         throw new PrologError('type_error(callable)', culprit);
       }

package/src/quads.js

@@ -247,7 +247,10 @@ function executeQuery(program, query, input, maxSolutions, options) {
     error,
     tailOutput,
     inputPosition,
-    loops: solver.depthLimitExceeded || solver.inferenceLimitExceeded,
+    // Accept direct structural evidence from EyeProlog's recursion guard as
+    // well as bounded-search evidence. A detected active-variant cycle is
+    // stronger evidence than merely reaching a timeout/inference ceiling.
+    loops: solver.recursionCycleDetected || solver.depthLimitExceeded || solver.inferenceLimitExceeded,
   };
 }
 

package/src/solver.js

@@ -63,6 +63,10 @@ export class Solver {
     // limit accounting. time/1 snapshots this counter around the measured goal.
     this.inferenceObservation = options.inferenceObservation ?? { value: 0 };
     this.inferenceLimitExceeded = false;
+    // Set when the normal-profile recursion guard detects re-entry of an
+    // already active variant on the current search path. Quad `loops` checks
+    // use this structural evidence in addition to bounded resource probes.
+    this.recursionCycleDetected = false;
     this.maxMemoryBytes = options.maxMemoryBytes ?? softHeapLimit();
     this.memoryRecovery = options.memoryRecovery ?? {
       active: false,
@@ -261,6 +265,7 @@ export class Solver {
     if (!child || child === this || !child.stats) return;
     this.depthLimitExceeded ||= child.depthLimitExceeded;
     this.inferenceLimitExceeded ||= child.inferenceLimitExceeded;
+    this.recursionCycleDetected ||= child.recursionCycleDetected;
     for (const [key, value] of Object.entries(child.stats)) {
       if (key === 'max_depth' || key === 'max_goal_count') {
         this.stats[key] = Math.max(this.stats[key] ?? 0, value ?? 0);
@@ -845,7 +850,10 @@ export class Solver {
   }
 
   *solveUserGoalUncached(group, goal, rest, env, depth) {
-    if (group.recursive && !group.cutRecursive && !group.linearNumeric && this.activeVariant(goal, env)) return;
+    if (group.recursive && !group.cutRecursive && !group.linearNumeric && this.activeVariant(goal, env)) {
+      this.recursionCycleDetected = true;
+      return;
+    }
     // Program indexes provide candidate clauses, but every candidate is still
     // freshened and unified below. The index is a performance hint, not a
     // semantic shortcut.
@@ -1047,7 +1055,10 @@ function pushMemoAnswerFrames(stack, entry, goal, rest, env, depth, active, solv
 }
 
 function pushUserGoalUncachedFrames(stack, solver, group, goal, rest, env, depth, active) {
-  if (group.recursive && !group.cutRecursive && !group.linearNumeric && activeVariantIn(goal, env, active)) return;
+  if (group.recursive && !group.cutRecursive && !group.linearNumeric && activeVariantIn(goal, env, active)) {
+    solver.recursionCycleDetected = true;
+    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;
@@ -1981,7 +1992,10 @@ function tryPushScalarFactRunFrames(stack, solver, goals, env, depth, active) {
     }
 
     const goal = runGoals[state.index];
-    if (activeMightContain(goal, active) && activeVariantIn(goal, envWithLocal(env, state.names, state.values), active)) continue;
+    if (activeMightContain(goal, active) && activeVariantIn(goal, envWithLocal(env, state.names, state.values), active)) {
+      solver.recursionCycleDetected = true;
+      continue;
+    }
     solver.stats.solve_one_goal_calls++;
     const candidates = selectScalarFactCandidates(groups[state.index], goal, env, state.names, state.values);
     const nextStates = [];
@@ -2035,7 +2049,10 @@ function* scalarFactRunSolutions(solver, goals, groups, env, depth, active) {
     }
 
     const goal = goals[state.index];
-    if (activeMightContain(goal, active) && activeVariantIn(goal, envWithLocal(env, state.names, state.values), active)) continue;
+    if (activeMightContain(goal, active) && activeVariantIn(goal, envWithLocal(env, state.names, state.values), active)) {
+      solver.recursionCycleDetected = true;
+      continue;
+    }
     solver.stats.solve_one_goal_calls++;
     const candidates = selectScalarFactCandidates(groups[state.index], goal, env, state.names, state.values);
     const nextStates = [];
@@ -2205,7 +2222,11 @@ function tryPushCompactBinaryChainFrames(stack, solver, group, goal, rest, env,
     if (solver.solutionsSeen >= solver.solutionLimit) return true;
     solver.stats.max_depth = Math.max(solver.stats.max_depth, currentDepth);
     const seenSet = seen[secondType];
-    if (!seenSet || seenSet.has(secondName)) return true;
+    if (!seenSet) return true;
+    if (seenSet.has(secondName)) {
+      solver.recursionCycleDetected = true;
+      return true;
+    }
     if (cache[secondType].has(secondName)) {
       rememberCompactChainSuccess(cache, seen);
       stack.push({ kind: 'goals', goals: rest, env, depth: depth + 1, active });
@@ -2326,8 +2347,14 @@ function tryPushGroundChainFrames(stack, solver, group, goal, rest, env, depth,
     if (solver.solutionsSeen >= solver.solutionLimit) return true;
     solver.stats.max_depth = Math.max(solver.stats.max_depth, currentDepth);
     const key = groundChainKey(currentGoal);
-    if (seen.has(key)) return true;
-    if (activeVariantIn(currentGoal, currentEnv, active)) return true;
+    if (seen.has(key)) {
+      solver.recursionCycleDetected = true;
+      return true;
+    }
+    if (activeVariantIn(currentGoal, currentEnv, active)) {
+      solver.recursionCycleDetected = true;
+      return true;
+    }
     if (solver.groundChainSuccess.has(key)) {
       rememberGroundChainSuccess(solver, seen);
       stack.push({ kind: 'goals', goals: rest, env: baseEnv, depth: depth + 1, active });

package/test/run-regression.mjs

@@ -1317,6 +1317,22 @@ c4 ?- call((!;1)).
         assertEqual(result.stdout, 'quads: 1 run, 1 passed, 0 failed.\n', 'quad report');
       },
     },
+    {
+      name: 'runQuads preserves output before a delayed call/1 instantiation error (issue #57)',
+      run: () => {
+        const result = publicApi.runQuads(`16, "7.8.3.4#9"\n?- call((write(3), X)).\n   outputs("3"), instantiation_error.\n`);
+        assertEqual(result.passed, 1, 'quad passed');
+        assertEqual(result.stdout, 'quads: 1 run, 1 passed, 0 failed.\n', 'quad report');
+      },
+    },
+    {
+      name: 'runQuads recognizes recursion-guard cycle evidence as loops (issue #58)',
+      run: () => {
+        const result = publicApi.runQuads(`inf :- inf, inf.\n\n23\n?- inf.\n   loops.\n`);
+        assertEqual(result.passed, 1, 'quad passed');
+        assertEqual(result.stdout, 'quads: 1 run, 1 passed, 0 failed.\n', 'quad report');
+      },
+    },
     {
       name: '--quads runs embedded tests and reports failures through exit status',
       run: () => {

package/the-art-of-eyeprolog.md

@@ -6831,9 +6831,12 @@ variable in the renamed exception term. `...` and `ad_infinitum` accept further
 indented descriptions after one query are independent checks: each re-runs the
 query, each is counted in the `quads:` summary, and a failing description does
 not suppress later descriptions for that query. `inputs/1` supplies and checks
-consumed characters; `outputs/1` checks emitted characters. `sto` marks
-an answer description that this finite-tree implementation skips. `loops` is
-checked with a deterministic solver-depth budget. The advanced stream
+consumed characters; `outputs/1` checks characters emitted while reaching
+the described answer or error, including output produced before a later
+exception. `sto` marks an answer description that this finite-tree
+implementation skips. `loops` accepts direct active-variant cycle evidence from
+EyeProlog's normal recursion guard, with bounded depth/inference exhaustion as a
+fallback for loops that have no such structural witness. The advanced stream
 annotations `peeks/1` and `waits`, and the unordered `other_answer_sequence`
 annotation, are not executed by the current runner.