eyeprolog 1.2.33 → 1.2.35

package/index.d.ts

@@ -93,6 +93,7 @@ export interface EyePrologPredicateGroup {
   rejectedDemandIndexes: Set<string>;
   tabled: boolean;
   recursive: boolean;
+  listTailRecursive: boolean;
   tableInputPositions: number[];
   negationStratum: number | null;
 }
@@ -107,6 +108,14 @@ export class Term {
   get arity(): number;
 }
 
+export class CompactListTerm {
+  readonly type: 'compound';
+  readonly name: '.';
+  readonly args: EyePrologTerm[];
+  readonly arity: 2;
+  mayContainVariable(name: string): boolean;
+}
+
 export class Env {
   constructor(bindings?: Iterable<readonly [string, EyePrologTerm]> | null);
   bindings: Map<string, EyePrologTerm>;
@@ -198,6 +207,9 @@ export function numberTerm(value: string | number): Term;
 export function compound(name: string, args?: EyePrologTerm[]): Term;
 export function emptyList(): Term;
 export function cons(head: EyePrologTerm, tail: EyePrologTerm): Term;
+export function compactVariableList(length: bigint | number | string, variablePrefix: string): CompactListTerm | Term;
+export function isCompactList(term: EyePrologTerm | null | undefined): term is CompactListTerm;
+export function compactListLength(term: EyePrologTerm | null | undefined): bigint | null;
 export function deref(term: EyePrologTerm, env: Env): EyePrologTerm;
 export function isScalar(term: EyePrologTerm | null | undefined): boolean;
 export function isEmptyList(term: EyePrologTerm | null | undefined): boolean;
@@ -259,6 +271,7 @@ declare const eyeprolog: {
   NUMBER: typeof NUMBER;
   COMPOUND: typeof COMPOUND;
   Term: typeof Term;
+  CompactListTerm: typeof CompactListTerm;
   Env: typeof Env;
   Program: typeof Program;
   Solver: typeof Solver;
@@ -273,6 +286,9 @@ declare const eyeprolog: {
   compound: typeof compound;
   emptyList: typeof emptyList;
   cons: typeof cons;
+  compactVariableList: typeof compactVariableList;
+  isCompactList: typeof isCompactList;
+  compactListLength: typeof compactListLength;
   deref: typeof deref;
   isScalar: typeof isScalar;
   isEmptyList: typeof isEmptyList;

package/package.json

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

package/src/iso.js

@@ -2029,35 +2029,39 @@ function* negationBuiltin({ solver, goal, env }) {
   for (const _ of solver.cloneForInnerGoal(1).solve([callable(goal.args[0], env)], env.clone(), 0)) return;
   yield env;
 }
+function* solveControlBranch(solver, goal, env) {
+  for (const answer of solver.solve([callable(goal, env)], env, 0)) {
+    // A branch answer is internal to its enclosing control construct. The
+    // surrounding solve will count the completed control goal after the
+    // builtin yields it. Leaving both counts in place makes a bounded search
+    // such as once/1 or negation stop before it can observe the branch answer.
+    if (solver.solutionsSeen > 0) solver.solutionsSeen--;
+    yield answer;
+  }
+}
 function* disjunctionBuiltin({ solver, goal, env }) {
   const left = deref(goal.args[0], env);
   if (left.type === COMPOUND && left.name === '->' && left.arity === 2) {
     for (const conditionEnv of solver.cloneForInnerGoal(1).solve([callable(left.args[0], env)], env.clone(), 0)) {
-      yield* solver.solve([callable(left.args[1], conditionEnv)], conditionEnv, 0);
+      yield* solveControlBranch(solver, left.args[1], conditionEnv);
       return;
     }
-    yield* solver.solve([callable(goal.args[1], env)], env.clone(), 0);
+    yield* solveControlBranch(solver, goal.args[1], env.clone());
     return;
   }
   const marker = solver.active[solver.active.length - 1] ?? null;
   const markerCutEpoch = marker?.cutEpoch ?? 0;
   const solverCutEpoch = solver.cutEpoch;
-  yield* solver.solve([callable(goal.args[0], env)], env.clone(), 0);
+  yield* solveControlBranch(solver, goal.args[0], env.clone());
   const cutThisScope = marker == null
     ? solver.cutEpoch !== solverCutEpoch
     : (marker.cutEpoch ?? 0) !== markerCutEpoch;
   if (cutThisScope) return;
-  yield* solver.solve([callable(goal.args[1], env)], env.clone(), 0);
+  yield* solveControlBranch(solver, goal.args[1], env.clone());
 }
 function* ifThenBuiltin({ solver, goal, env }) {
   for (const conditionEnv of solver.cloneForInnerGoal(1).solve([callable(goal.args[0], env)], env.clone(), 0)) {
-    for (const consequentEnv of solver.solve([callable(goal.args[1], conditionEnv)], conditionEnv, 0)) {
-      // The consequent is an internal part of the current solution, not a
-      // completed top-level solution. Keep a surrounding bounded search (for
-      // example nested ISO once-as-if-then) from consuming its limit early.
-      if (solver.solutionsSeen > 0) solver.solutionsSeen--;
-      yield consequentEnv;
-    }
+    yield* solveControlBranch(solver, goal.args[1], conditionEnv);
     return;
   }
 }

package/src/platform.js

@@ -43,6 +43,14 @@ export function usedHeapSize() {
 }
 
 export function softHeapLimit() {
+  const limit = hardHeapLimit();
+  // Leave ample room for the generator stack to unwind and for the top level
+  // to construct and print resource_error(memory). Fatal V8 OOMs cannot be
+  // caught after the heap limit itself has been reached.
+  return Number.isFinite(limit) && limit > 0 ? Math.floor(limit * 0.75) : Infinity;
+}
+
+export function hardHeapLimit() {
   let limit = null;
   if (isNode) {
     limit = v8?.getHeapStatistics?.().heap_size_limit ?? null;
@@ -51,10 +59,7 @@ export function softHeapLimit() {
     const memory = globalThis.performance?.memory;
     if (Number.isFinite(memory?.jsHeapSizeLimit)) limit = memory.jsHeapSizeLimit;
   }
-  // Leave ample room for the generator stack to unwind and for the top level
-  // to construct and print resource_error(memory). Fatal V8 OOMs cannot be
-  // caught after the heap limit itself has been reached.
-  return Number.isFinite(limit) && limit > 0 ? Math.floor(limit * 0.75) : Infinity;
+  return Number.isFinite(limit) && limit > 0 ? limit : Infinity;
 }
 
 function configuredOldSpaceBytes() {

package/src/program.js

@@ -368,6 +368,11 @@ export class Program {
         (isPiAccumulator(group) || isPortableBetweenGenerator(group));
       group.linearNumeric = linearNumeric;
       group.fastPi = linearNumeric && isPiAccumulator(group);
+      const directRecursiveComponent = plannedRecursive && [...deps[start]].every((dependency) =>
+        dependency === start || !reachableIndexes(dependency, deps).has(start)
+      );
+      group.listTailRecursive = directRecursiveComponent && !group.cutRecursive &&
+        hasStrictListTailRecursion(group);
       group.tabled = plannedRecursive &&
         !componentHasNegativeEdge(start, deps, negativeEdges) &&
         !group.cutRecursive &&
@@ -1063,6 +1068,25 @@ function inferStructuralInputPositions(group) {
   return Array.from({ length: group.arity }, (_, index) => index);
 }
 
+function hasStrictListTailRecursion(group) {
+  let foundRecursiveCall = false;
+  for (const clause of group.clauses) {
+    if (isCompactBinaryClause(clause)) return false;
+    for (const goal of clause.body) {
+      if (goal.type !== COMPOUND || goal.name !== group.name || goal.arity !== group.arity) continue;
+      foundRecursiveCall = true;
+      const decreases = goal.args.some((argument, index) => {
+        const head = clause.head.args[index];
+        return head?.type === COMPOUND && head.name === '.' && head.arity === 2 &&
+          head.args[1]?.type === VAR && argument?.type === VAR &&
+          head.args[1].name === argument.name;
+      });
+      if (!decreases) return false;
+    }
+  }
+  return foundRecursiveCall;
+}
+
 function hasLinearNumericRecursion(group) {
   let recursiveClause = null;
   for (const clause of group.clauses) {

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 {
-  COMPOUND, NUMBER, VAR, Env, compound, cons, copyResolved, deref, emptyList,
+  COMPOUND, NUMBER, VAR, Env, compactListLength, compactVariableList, compound, cons, copyResolved, deref, emptyList,
   flattenConjunction, freshTerm, isCons, isDecimalInteger, isEmptyList,
   numberTerm, numberTextFromDouble, termIsGround, termToString, unify, variable, variantTerms,
 } from './term.js';
@@ -11,7 +11,7 @@ import { getEyePrologRegistry } from './standard-library.js';
 import { selectClauseCandidates, selectClauseCandidatesForValues, selectGroundClauseCandidates } from './program.js';
 import { StreamManager } from './io.js';
 import { clpzStateConsistent } from './clpz.js';
-import { softHeapLimit, usedHeapSize } from './platform.js';
+import { hardHeapLimit, softHeapLimit, usedHeapSize } from './platform.js';
 
 let freshCounter = 0;
 
@@ -51,6 +51,11 @@ export class Solver {
     this.inferences = 0;
     this.inferenceLimitExceeded = false;
     this.maxMemoryBytes = options.maxMemoryBytes ?? softHeapLimit();
+    this.memoryRecovery = options.memoryRecovery ?? {
+      active: false,
+      reservationBytes: 0,
+      checks: 0,
+    };
     this.nextMemoryCheck = 0;
     // 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
@@ -121,6 +126,7 @@ export class Solver {
       maxDepth: this.maxDepth,
       maxInferences: this.maxInferences,
       maxMemoryBytes: this.maxMemoryBytes,
+      memoryRecovery: this.memoryRecovery,
       solutionLimit,
       isoStrict: this.isoStrict,
       prologFlags: this.prologFlags,
@@ -424,7 +430,18 @@ export class Solver {
       }
       }
     } catch (error) {
-      throw normalizeHostResourceError(error);
+      const normalized = normalizeHostResourceError(error);
+      if (normalized instanceof PrologError && normalized.formal === 'resource_error(memory)') {
+        // Unwinding makes query-local terms unreachable, but hosts are free to
+        // postpone collection. Give the shared solver family bounded breathing
+        // room on its next query so a GC can observe those released references.
+        if (!this.memoryRecovery.active) {
+          this.memoryRecovery.active = true;
+          this.memoryRecovery.reservationBytes = 1024 * 1024;
+          this.memoryRecovery.checks = 16;
+        }
+      }
+      throw normalized;
     } finally {
       const stackIndex = this.solveStacks.indexOf(registeredStack);
       if (stackIndex >= 0) this.solveStacks.splice(stackIndex, 1);
@@ -441,7 +458,12 @@ export class Solver {
     this.nextMemoryCheck = this.inferences + 256;
     if (!Number.isFinite(this.maxMemoryBytes)) return;
     const used = usedHeapSize();
-    if (used != null && used >= this.maxMemoryBytes) {
+    if (used != null && used < this.maxMemoryBytes) this.finishMemoryRecovery();
+    if (used != null && used >= this.currentMemoryLimit()) {
+      if (this.memoryRecovery.active && this.memoryRecovery.checks > 0) {
+        this.memoryRecovery.checks--;
+        return;
+      }
       throw new PrologError('resource_error(memory)');
     }
   }
@@ -449,11 +471,32 @@ export class Solver {
   checkMemoryReservation(bytes) {
     if (!Number.isFinite(this.maxMemoryBytes) || !Number.isFinite(bytes) || bytes <= 0) return;
     const used = usedHeapSize();
-    if (used != null && bytes > Math.max(0, this.maxMemoryBytes - used)) {
+    if (used != null && used < this.maxMemoryBytes) this.finishMemoryRecovery();
+    if (used != null && bytes > Math.max(0, this.currentMemoryLimit() - used)) {
+      if (this.memoryRecovery.active && bytes <= this.memoryRecovery.reservationBytes) {
+        this.memoryRecovery.reservationBytes -= bytes;
+        return;
+      }
       throw new PrologError('resource_error(memory)');
     }
   }
 
+  currentMemoryLimit() {
+    if (!this.memoryRecovery.active) return this.maxMemoryBytes;
+    // Retain at least five percent of the actual host ceiling for error
+    // construction and unwinding. For an embedder-supplied lower soft limit,
+    // cap the temporary recovery window as well.
+    const hostSafetyLimit = hardHeapLimit() * 0.95;
+    const recoveryAllowance = Math.max(8 * 1024 * 1024, this.maxMemoryBytes * 0.125);
+    return Math.min(hostSafetyLimit, this.maxMemoryBytes + recoveryAllowance);
+  }
+
+  finishMemoryRecovery() {
+    this.memoryRecovery.active = false;
+    this.memoryRecovery.reservationBytes = 0;
+    this.memoryRecovery.checks = 0;
+  }
+
   *solveUserGoal(goal, rest, env, depth) {
     this.stats.solve_one_goal_calls++;
     if (depth > this.maxDepth) {
@@ -700,6 +743,10 @@ function pushUserGoalUncachedFrames(stack, solver, group, goal, rest, env, depth
 }
 
 function groupNeedsActiveFrame(group) {
+  // A direct recursive call that consumes the tail of a matched list cannot
+  // revisit an earlier finite-tree call. It needs neither a cycle guard nor an
+  // O(depth) copy of the active-call stack at every element.
+  if (group.listTailRecursive === true && group.hasCut !== true) return false;
   // User code may observe the surrounding control context through later cuts,
   // so only apply this planning shortcut to the fixed bundled-library graph.
   if (group.bundledLibrary !== true) return true;
@@ -772,23 +819,21 @@ function* fixedLengthSolutions(solver, list, length, env) {
     return;
   }
 
-  // A materialized list cell with its fresh variable occupies roughly 216
-  // bytes on current V8 builds. Reserve conservatively before constructing a
-  // huge list so a resource_error does not leave the heap at the soft limit
-  // and poison the next query.
-  const estimatedListCellBytes = 256n;
   if (remaining > BigInt(Number.MAX_SAFE_INTEGER)) throw new PrologError('resource_error(memory)');
-  solver.checkMemoryReservation(Number(remaining * estimatedListCellBytes));
-
   const id = nextFreshId();
-  let suffix = emptyList();
-  for (let index = 0n; index < remaining; index++) {
-    suffix = cons(variable(`__length${id}_${index}`), suffix);
-    lengthAllocationCheckpoint(solver, ++steps);
-  }
+  // Keep an unobserved fixed-length list as one compact skeleton. Unification,
+  // list predicates, and readback expand it one cell at a time if its elements
+  // are actually inspected.
+  solver.checkMemoryReservation(256);
+  const suffix = compactVariableList(remaining, `__length${id}_`);
   const next = env.clone();
   solver.stats.unify_calls++;
-  if (unify(cursor, suffix, next)) yield next;
+  // cursor is dereferenced and the compact skeleton contains only freshly
+  // generated variables, so this binding cannot create a cycle. Binding it
+  // directly avoids traversing and expanding the new skeleton for an occurs
+  // check whose result is known by construction.
+  next.bind(cursor.name, suffix);
+  yield next;
 }
 
 function* generatedLengthSolutions(solver, list, length, env) {
@@ -1338,18 +1383,61 @@ function variantShape(term, env) {
   return term.args.map((arg) => variantArgumentSize(arg, env)).join(',');
 }
 
+const rawProperListLengths = new WeakMap();
+
+function rawProperListLength(term) {
+  const compactLength = compactListLength(term);
+  if (compactLength != null) return compactLength;
+  if (!isCons(term)) return null;
+  const cells = [];
+  const seen = new WeakSet();
+  let cursor = term;
+  let suffixLength = 0;
+  while (isCons(cursor)) {
+    const cached = rawProperListLengths.get(cursor);
+    if (cached != null) {
+      suffixLength = cached;
+      break;
+    }
+    if (seen.has(cursor)) return null;
+    seen.add(cursor);
+    cells.push(cursor);
+    // Only cache the raw spine. A variable tail may resolve differently in
+    // separate environments and therefore needs the general shape walk.
+    cursor = cursor.args[1];
+  }
+  if (!isEmptyList(cursor) && rawProperListLengths.get(cursor) == null) return null;
+  for (let index = cells.length - 1; index >= 0; index--) {
+    rawProperListLengths.set(cells[index], ++suffixLength);
+  }
+  return rawProperListLengths.get(term) ?? suffixLength;
+}
+
 function variantArgumentSize(term, env) {
-  const pending = [term];
+  const resolved = derefForLocal(term, env);
+  const listLength = rawProperListLength(resolved);
+  if (listLength != null) return `list:${listLength}`;
+  const pending = [{ term, exit: false }];
+  const ancestors = new WeakSet();
   let size = 0;
   while (pending.length > 0) {
-    const current = derefForLocal(pending.pop(), env);
+    const item = pending.pop();
+    if (item.exit) {
+      ancestors.delete(item.term);
+      continue;
+    }
+    const current = derefForLocal(item.term, env);
     size++;
-    // This is only a rejection key. Capping keeps pathological cyclic or very
-    // large terms bounded; equal capped sizes still fall through to the exact
-    // variant check.
-    if (size > 4096) return 4097;
     if (current?.type === COMPOUND) {
-      for (let index = 0; index < current.arity; index++) pending.push(current.args[index]);
+      // Finite terms get an exact size, which cheaply distinguishes successive
+      // tails of a long list. Keep cyclic terms conservative so the exact
+      // variant check remains authoritative.
+      if (ancestors.has(current)) return '*';
+      ancestors.add(current);
+      pending.push({ term: current, exit: true });
+      for (let index = current.arity - 1; index >= 0; index--) {
+        pending.push({ term: current.args[index], exit: false });
+      }
     }
   }
   return size;
@@ -1400,45 +1488,58 @@ function derefForLocal(term, env) {
 }
 
 function memoKey(goal, env, group = null) {
-  let hasBound = false;
-  const variables = new Map();
   const required = group?.tableInputPositions ?? [];
-  const ground = [];
+  const ground = goal.args.map((arg) => termIsGround(arg, env));
+  const hasBound = required.length > 0
+    ? required.some((index) => ground[index])
+    : ground.some(Boolean);
+  // Automatic tabling only admits calls with a ground input. Avoid building a
+  // potentially huge canonical key for the non-ground structural calls that
+  // will use the ordinary active-call guard instead.
+  if (!hasBound) return { hasBound: false, text: '' };
+
+  const variables = new Map();
   const parts = goal.args.map((arg) => {
     const value = derefForLocal(arg, env);
-    if (value.type === 'var') {
-      ground.push(false);
-      return '_';
-    }
-    const canonical = canonicalTermInfo(value, env, variables);
-    ground.push(canonical.ground);
-    if (canonical.ground) hasBound = true;
-    return canonical.key;
+    return value.type === 'var' ? '_' : canonicalTermKey(value, env, variables);
   });
-  if (required.length > 0) {
-    hasBound = required.some((index) => ground[index]);
-  }
   return { hasBound, text: parts.join('|') };
 }
 
-function canonicalTermInfo(term, env, variables) {
-  const value = derefForLocal(term, env);
-  if (value.type === 'var') {
-    let id = variables.get(value.name);
-    if (id == null) {
-      id = variables.size;
-      variables.set(value.name, id);
+function canonicalTermKey(term, env, variables) {
+  // Memo keys are needed before deciding whether a recursive call is tabled.
+  // Build them iteratively: a perfectly ordinary bound list can be deeper than
+  // JavaScript's native call stack even though the solver itself is iterative.
+  const key = [];
+  const pending = [{ kind: 'term', term }];
+  while (pending.length > 0) {
+    const item = pending.pop();
+    if (item.kind === 'text') {
+      key.push(item.text);
+      continue;
+    }
+    const value = derefForLocal(item.term, env);
+    if (value.type === 'var') {
+      let id = variables.get(value.name);
+      if (id == null) {
+        id = variables.size;
+        variables.set(value.name, id);
+      }
+      key.push(`var:${id}`);
+      continue;
+    }
+    if (!value.args?.length) {
+      key.push(`${value.type}:${value.name}`);
+      continue;
+    }
+    key.push(`${value.type}:${value.name}(`);
+    pending.push({ kind: 'text', text: ')' });
+    for (let index = value.args.length - 1; index >= 0; index--) {
+      if (index < value.args.length - 1) pending.push({ kind: 'text', text: ',' });
+      pending.push({ kind: 'term', term: value.args[index] });
     }
-    return { key: `var:${id}`, ground: false };
   }
-  if (!value.args?.length) return { key: `${value.type}:${value.name}`, ground: true };
-  let ground = true;
-  const keys = value.args.map((arg) => {
-    const child = canonicalTermInfo(arg, env, variables);
-    if (!child.ground) ground = false;
-    return child.key;
-  });
-  return { key: `${value.type}:${value.name}(${keys.join(',')})`, ground };
+  return key.join('');
 }
 
 function copyResolvedWithKey(term, env, variables) {

package/src/term.js

@@ -8,6 +8,7 @@ export const STRING = 'string';
 export const NUMBER = 'number';
 export const COMPOUND = 'compound';
 const EMPTY_ARGS = Object.freeze([]);
+const ENV_FLATTEN_DEPTH = 1024;
 
 export class Term {
   constructor(type, name, args = []) {
@@ -20,6 +21,55 @@ export class Term {
   }
 }
 
+// A fixed-length list of fresh variables is represented as one compact
+// skeleton and expanded cell-by-cell only when a goal actually inspects it.
+// This keeps ordinary logical construction proportional to what the program
+// observes instead of eagerly allocating two host objects per list element.
+export class CompactListTerm {
+  constructor(length, variablePrefix, offset = 0n, state = null) {
+    this.type = COMPOUND;
+    this.name = '.';
+    this._compactLength = BigInt(length);
+    this._variablePrefix = variablePrefix;
+    this._offset = BigInt(offset);
+    this._compactState = state ?? { maxPossiblyBoundIndex: -1n };
+    this._args = null;
+  }
+  get arity() {
+    return 2;
+  }
+  get args() {
+    if (this._args == null) {
+      const head = variable(`${this._variablePrefix}${this._offset}`);
+      head._compactState = this._compactState;
+      head._compactIndex = this._offset;
+      const tail = this._compactLength === 1n
+        ? emptyList()
+        : new CompactListTerm(
+          this._compactLength - 1n,
+          this._variablePrefix,
+          this._offset + 1n,
+          this._compactState,
+        );
+      this._args = [head, tail];
+    }
+    return this._args;
+  }
+  mayContainVariable(name) {
+    if (String(name).startsWith(this._variablePrefix)) {
+      const indexText = String(name).slice(this._variablePrefix.length);
+      if (/^\d+$/.test(indexText)) {
+        const index = BigInt(indexText);
+        if (index >= this._offset && index < this._offset + this._compactLength) return true;
+      }
+    }
+    // If no generated head in this suffix has ever participated in a binding,
+    // an unrelated variable cannot occur below it. This remains conservative
+    // across backtracking because the high-water mark is never rolled back.
+    return this._compactState.maxPossiblyBoundIndex >= this._offset;
+  }
+}
+
 export const variable = (name) => new Term(VAR, name, EMPTY_ARGS);
 export const atom = (name) => new Term(ATOM, name, EMPTY_ARGS);
 export const stringTerm = (value) => new Term(STRING, value, EMPTY_ARGS);
@@ -27,6 +77,12 @@ export const numberTerm = (value) => new Term(NUMBER, value, EMPTY_ARGS);
 export const compound = (name, args = []) => args.length === 0 ? atom(name) : new Term(COMPOUND, name, args);
 export const emptyList = () => atom('[]');
 export const cons = (head, tail) => compound('.', [head, tail]);
+export const compactVariableList = (length, variablePrefix) => {
+  const size = BigInt(length);
+  return size === 0n ? emptyList() : new CompactListTerm(size, variablePrefix);
+};
+export const isCompactList = (term) => term instanceof CompactListTerm;
+export const compactListLength = (term) => isCompactList(term) ? term._compactLength : null;
 
 export class Env {
   constructor(bindings) {
@@ -94,7 +150,7 @@ export class Env {
     return undefined;
   }
   bind(name, term) {
-    if (this._state.depth >= 32) {
+    if (this._state.depth >= ENV_FLATTEN_DEPTH) {
       const flattened = new Map();
       for (let state = this._state; state != null; state = state.parent) {
         if (state.bindingName != null && !flattened.has(state.bindingName)) {
@@ -200,6 +256,7 @@ function occurs(variableName, term, env) {
       if (binding !== undefined) stack.push(binding);
       continue;
     }
+    if (isCompactList(current) && !current.mayContainVariable(variableName)) continue;
     if (current?.type !== COMPOUND || seenTerms.has(current)) continue;
     seenTerms.add(current);
     for (let i = 0; i < current.arity; i++) stack.push(current.args[i]);
@@ -224,6 +281,7 @@ export function unify(left, right, env, options = {}) {
     if (a.type === VAR && b.type === VAR) {
       // Both variables are already dereferenced and unbound, so linking them
       // cannot create a cycle and needs no occurs-check traversal.
+      markCompactVariableBound(a);
       env.bind(a.name, b);
       continue;
     }
@@ -232,6 +290,7 @@ export function unify(left, right, env, options = {}) {
         occursCheckHandler?.(a, b, env);
         return false;
       }
+      markCompactVariableBound(a);
       env.bind(a.name, b);
       continue;
     }
@@ -240,6 +299,7 @@ export function unify(left, right, env, options = {}) {
         occursCheckHandler?.(b, a, env);
         return false;
       }
+      markCompactVariableBound(b);
       env.bind(b.name, a);
       continue;
     }
@@ -264,6 +324,13 @@ export function unify(left, right, env, options = {}) {
   return true;
 }
 
+function markCompactVariableBound(term) {
+  if (term?._compactState == null || term._compactIndex == null) return;
+  if (term._compactIndex > term._compactState.maxPossiblyBoundIndex) {
+    term._compactState.maxPossiblyBoundIndex = term._compactIndex;
+  }
+}
+
 export function cloneTerm(term) {
   if (term.type === VAR) return variable(term.name);
   const cloned = term.type === COMPOUND && term.arity === 0
@@ -307,7 +374,12 @@ export function termIsGround(term, env = new Env()) {
     if (resolved.type === VAR) return false;
     if (seen.has(resolved)) continue;
     seen.add(resolved);
-    for (const arg of resolved.args) pending.push(arg);
+    // Visit leftmost arguments first. Lists and other recursive structures
+    // commonly carry their first unbound variable there, allowing a
+    // non-ground check to finish without walking the complete tail.
+    for (let index = resolved.args.length - 1; index >= 0; index--) {
+      pending.push(resolved.args[index]);
+    }
   }
   return true;
 }
@@ -505,21 +577,37 @@ export function termSignature(term) {
 }
 
 export function variantTerms(left, leftEnv, right, rightEnv, pairs = new Map(), reverse = new Map()) {
-  left = deref(left, leftEnv);
-  right = deref(right, rightEnv);
-  if (left.type === VAR || right.type === VAR) {
-    if (left.type !== VAR || right.type !== VAR) return false;
-    if (pairs.has(left.name) || reverse.has(right.name)) {
-      return pairs.get(left.name) === right.name && reverse.get(right.name) === left.name;
+  // Variant checks sit on the recursive-call hot path. Use an explicit work
+  // stack so long lists do not consume the JavaScript call stack.
+  const pending = [[left, right]];
+  const seen = new WeakMap();
+  while (pending.length > 0) {
+    [left, right] = pending.pop();
+    left = deref(left, leftEnv);
+    right = deref(right, rightEnv);
+    if (left.type === VAR || right.type === VAR) {
+      if (left.type !== VAR || right.type !== VAR) return false;
+      if (pairs.has(left.name) || reverse.has(right.name)) {
+        if (pairs.get(left.name) !== right.name || reverse.get(right.name) !== left.name) return false;
+        continue;
+      }
+      pairs.set(left.name, right.name);
+      reverse.set(right.name, left.name);
+      continue;
     }
-    pairs.set(left.name, right.name);
-    reverse.set(right.name, left.name);
-    return true;
-  }
-  if (left.type !== right.type || left.arity !== right.arity) return false;
-  if (left.type === NUMBER ? !sameNumberValue(left.name, right.name) : left.name !== right.name) return false;
-  for (let i = 0; i < left.arity; i++) {
-    if (!variantTerms(left.args[i], leftEnv, right.args[i], rightEnv, pairs, reverse)) return false;
+
+    if (left.type !== right.type || left.arity !== right.arity) return false;
+    if (left.type === NUMBER ? !sameNumberValue(left.name, right.name) : left.name !== right.name) return false;
+    if (left.type !== COMPOUND) continue;
+
+    let rights = seen.get(left);
+    if (rights?.has(right)) continue;
+    if (rights == null) {
+      rights = new WeakSet();
+      seen.set(left, rights);
+    }
+    rights.add(right);
+    for (let i = left.arity - 1; i >= 0; i--) pending.push([left.args[i], right.args[i]]);
   }
   return true;
 }

package/test/run-regression.mjs

@@ -477,6 +477,32 @@ c4 ?- call((!;1)).
         assertEqual(result.stdout, 'quads: 22 run, 22 passed, 0 failed.\n', 'quad report');
       },
     },
+    {
+      name: 'negation observes disjunction through direct and call/1 execution',
+      run: () => {
+        const reported = publicApi.runQuads(String.raw`?- \+ (true ; true).
+   false.
+
+?- call(\+ (true ; true)).
+   false.
+`);
+        assertEqual(reported.total, 2, 'reported query count');
+        assertEqual(reported.passed, 2, 'reported queries pass');
+
+        const program = Program.parse('');
+        const answerCount = (text) => {
+          const solver = new Solver(program, { registry: getEyePrologRegistry() });
+          return [...solver.solve([parseGoalText(text)], new Env(), 0)].length;
+        };
+
+        assertEqual(answerCount(String.raw`\+ (true ; true)`), 0, 'direct successful disjunction is negated');
+        assertEqual(answerCount(String.raw`call(\+ (true ; true))`), 0, 'called negation fails');
+        assertEqual(answerCount(String.raw`\+ (true ; fail)`), 0, 'successful left branch is observed');
+        assertEqual(answerCount(String.raw`\+ (fail ; true)`), 0, 'successful right branch is observed');
+        assertEqual(answerCount(String.raw`\+ (fail ; fail)`), 1, 'failed disjunction is negated');
+        assertEqual(answerCount('once((true ; true))'), 1, 'once keeps the first disjunction answer');
+      },
+    },
     {
       name: 'runQuads passes the complete vendored ISO phrase quad corpus',
       run: () => {
@@ -2796,7 +2822,7 @@ open(X) :- candidate(X), \\+ closed(X).
       },
     },
     {
-      name: 'resource_error(memory) leaves enough heap for subsequent list work',
+      name: 'discarded fixed-length lists stay compact under a bounded heap',
       run: () => {
         const engineUrl = new URL('../src/index.js', import.meta.url).href;
         const script = `
@@ -2807,11 +2833,75 @@ open(X) :- candidate(X), \\+ closed(X).
             const goal = parseGoalText(text, { operatorDefinitions: [...program.operators.values()] });
             return [...solver.solve([goal], new Env(), 0)];
           };
+          execute('length(L,10000000),fail');
+          if (execute('length(L,1),L=[X],X=L').length !== 0) {
+            throw new Error('compact list admitted a cyclic binding');
+          }
           execute('length(L,1000),fail');
+          process.stdout.write('compact');
+        `;
+        const result = spawnSync(process.execPath, [
+          '--max-old-space-size=64',
+          '--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, 'compact', 'discarded list skeleton does not exhaust the heap');
+      },
+    },
+    {
+      name: 'deep recursive list guards do not consume the host call stack',
+      run: () => {
+        const program = Program.parse('l([]).\nl([_|L]) :- l(L).\n', { sourceMetadata: false });
+        const left = listFromItems(Array.from({ length: 20000 }, (_, index) => variable(`L${index}`)));
+        const right = listFromItems(Array.from({ length: 20000 }, (_, index) => variable(`R${index}`)));
+        const solver = new Solver(program, {
+          registry: getEyePrologRegistry(),
+          maxDepth: 0,
+          maxMemoryBytes: Infinity,
+        });
+        const answers = [...solver.solve([compound('l', [left])], new Env(), 0)];
+        assertEqual(answers.length, 0, 'depth bound stops after stack-safe memo classification');
+        assertEqual(variantTerms(left, new Env(), right, new Env()), true, 'deep lists are variants');
+      },
+    },
+    {
+      name: 'discarded recursive allocations recover after resource_error(memory)',
+      run: () => {
+        const engineUrl = new URL('../src/index.js', import.meta.url).href;
+        const programText = `
+          :- use_module(library(prologue)).
+          l([]).
+          l([E|L]) :- length(E,1000), l(L).
+        `;
+        const reportedGoal = 'length(_,I),N is 2^I,\\+ \\+ (length(L,N),l(L)),L=[_|_]';
+        const script = `
+          import { Program, Solver, Env, deref, variable, parseGoalText, getEyePrologRegistry } from ${JSON.stringify(engineUrl)};
+          const program = Program.parse(${JSON.stringify(programText)}, { sourceMetadata: false });
+          const solver = new Solver(program, { registry: getEyePrologRegistry() });
+          const execute = (text) => {
+            const goal = parseGoalText(text, { operatorDefinitions: [...program.operators.values()] });
+            return [...solver.solve([goal], new Env(), 0)];
+          };
+          const reported = parseGoalText(${JSON.stringify(reportedGoal)}, {
+            operatorDefinitions: [...program.operators.values()],
+          });
+          let reportedAnswers = 0;
+          for (const answer of solver.solve([reported], new Env(), 0)) {
+            reportedAnswers++;
+            if (reportedAnswers !== 14) continue;
+            if (deref(variable('I'), answer).name !== '13' || deref(variable('N'), answer).name !== '8192') {
+              throw new Error('reported query did not reach I=13, N=8192');
+            }
+            break;
+          }
+          if (reportedAnswers !== 14) throw new Error('reported query produced too few answers');
           let caught = null;
-          try { execute('length(L,1000000),fail'); } catch (error) { caught = error; }
+          try { execute('length(L,32768),l(L)'); } catch (error) { caught = error; }
           if (caught?.formal !== 'resource_error(memory)') throw caught ?? new Error('no resource error');
-          execute('length(L,1000),fail');
+          if (execute('length(L,10),l(L)').length !== 1) throw new Error('recovery query failed');
           process.stdout.write('recovered');
         `;
         const result = spawnSync(process.execPath, [
@@ -2822,7 +2912,7 @@ open(X) :- candidate(X), \\+ closed(X).
         ], { 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, 'recovered', 'solver remains usable after resource error');
+        assertEqual(result.stdout, 'recovered', 'discarded recursive terms are collectible after unwinding');
       },
     },
     {

package/the-art-of-eyeprolog.md

@@ -1844,7 +1844,10 @@ normalized at the solver boundary instead of leaking a JavaScript `RangeError`.
 ISO 13211-1 leaves the resource atom implementation dependent. EyeProlog uses
 `memory` for a finite host allocation/capacity ceiling and reserves the
 `finite_memory` spelling for the distinct convention where no finite amount of
-memory could complete the computation.
+memory could complete the computation. After a recoverable memory error, the
+solver keeps a bounded recovery window while the failed search unwinds so the
+host can collect released query terms. The same solver can then run later
+queries; this recovery does not resume the query that exhausted its limit.
 
 The iterative solver keeps active-call frames only where they are semantically
 needed for cut scope or recursive variant guards. Bundled-library helpers whose
@@ -1853,9 +1856,15 @@ guard therefore do not copy a growing active-call sequence at every step.
 Under the normal EyeProlog registry, the bundled Prologue `length/2` also has a
 scoped iterative execution path: named lists are counted or constructed without
 recursive interpreter frames, and an anonymous list is not materialized because
-its binding cannot be observed. The ordinary clauses remain the authoritative
-module definition and are used unchanged by the ISO-only registry and whenever
-delays or finite-domain constraints require their normal wake-up points.
+its binding cannot be observed. A newly constructed fixed-length suffix starts
+as a lazy compact skeleton and expands one ordinary `./2` cell at a time when
+unification, another list predicate, or answer readback inspects it. This is a
+storage optimization, not a distinct Prolog term or list semantics. Embedders
+that inspect the JavaScript term model can recognize this representation with
+`CompactListTerm`, `isCompactList`, and `compactListLength`, or construct one
+with `compactVariableList`. The ordinary clauses remain the authoritative module
+definition and are used unchanged by the ISO-only registry and whenever delays
+or finite-domain constraints require their normal wake-up points.
 
 ### Implementation boundary