eyeprolog 1.4.9 → 1.4.10

package/index.d.ts

@@ -27,6 +27,8 @@ export interface EyePrologRunOptions {
   isoStrict?: boolean;
   /** Autoload uniquely mapped predicates from the conservative interop profile. Defaults to true outside strict ISO mode. */
   autoload?: boolean;
+  /** Automatically table recursive user predicates in normal mode. Defaults to true; set false for traditional depth-first control. */
+  autoTabling?: boolean;
   /** Initial ISO interpretation of double-quoted list notation. Defaults to chars. */
   doubleQuotes?: 'chars' | 'codes' | 'atom';
   ioOptions?: {

package/package.json

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

package/src/cleanup.js

@@ -46,7 +46,7 @@ export function installCleanupLifecycle(Solver) {
       if (!completed) {
         let closeError = null;
         try {
-          closeOwnedSearchStacks(this, state, owner, thrown != null);
+          if (state.active) closeOwnedSearchStacks(this, state, owner, thrown != null);
         } catch (error) {
           closeError = error;
         }
@@ -71,6 +71,7 @@ function ensureLifecycleState(solver) {
   const state = {
     owner: null,
     stackOwners: new WeakMap(),
+    active: false,
   };
   Object.defineProperty(solver, cleanupLifecycleState, { value: state });
 
@@ -81,7 +82,7 @@ function ensureLifecycleState(solver) {
   solveStacks.push = function cleanupAwarePush(...stacks) {
     for (const stack of stacks) {
       state.stackOwners.set(stack, state.owner);
-      patchSearchStack(stack);
+      if (state.active) patchSearchStack(stack);
     }
     return originalPush.apply(this, stacks);
   };
@@ -92,8 +93,10 @@ function ensureLifecycleState(solver) {
     // unwinding an exception, a cleanup exception must not replace it. Normal
     // consumer pruning closes frames earlier in cleanupAwareSolve(), where
     // cleanup errors are allowed to propagate.
-    for (let index = removed.length - 1; index >= 0; index--) {
-      closeSearchStack(removed[index], true);
+    if (state.active) {
+      for (let index = removed.length - 1; index >= 0; index--) {
+        closeSearchStack(removed[index], true);
+      }
     }
     return removed;
   };
@@ -111,6 +114,17 @@ function withOwner(state, owner, operation) {
   }
 }
 
+function activateCleanupLifecycle(solver) {
+  const state = ensureLifecycleState(solver);
+  if (state.active) return state;
+  state.active = true;
+  for (const stack of solver.solveStacks) {
+    if (!state.stackOwners.has(stack)) state.stackOwners.set(stack, state.owner);
+    patchSearchStack(stack);
+  }
+  return state;
+}
+
 function patchSearchStack(stack) {
   if (stack[searchStackPatched]) return;
   Object.defineProperty(stack, searchStackPatched, { value: true });
@@ -189,11 +203,13 @@ function firstSetupSolution(solver, setup, env) {
 }
 
 function callCleanupBuiltin({ solver, goal, env }) {
+  activateCleanupLifecycle(solver);
   const cleanup = callableTerm(goal.args[1], env);
   return cleanupProtectedIterator(solver, goal.args[0], cleanup, env);
 }
 
 function setupCallCleanupBuiltin({ solver, goal, env }) {
+  activateCleanupLifecycle(solver);
   let protectedIterator = null;
   let pending = true;
   const iterator = (function* setupThenProtected() {

package/src/cli.js

@@ -30,6 +30,7 @@ export async function main(argv) {
     isoStrict: false,
     portable: false,
     autoload: true,
+    autoTabling: true,
     version: false,
     warnings: false,
     goals: [],
@@ -57,6 +58,8 @@ export async function main(argv) {
       options.portable = true;
     } else if (!endOptions && arg === '--no-autoload') {
       options.autoload = false;
+    } else if (!endOptions && arg === '--no-auto-table') {
+      options.autoTabling = false;
     } else if (!endOptions && (arg === '--version' || arg === '-v')) {
       options.version = true;
     } else if (!endOptions && (arg === '--warnings' || arg === '-w')) {
@@ -153,6 +156,7 @@ export async function main(argv) {
     sourceMetadata: options.proof || options.isoStrict,
     isoStrict: options.isoStrict,
     autoload: options.autoload,
+    autoTabling: options.autoTabling,
     autoloadGoals: options.goals,
     onWarning: printSourceWarning,
   });
@@ -205,7 +209,10 @@ async function runDefault(engine, program, options) {
   const solver = new engine.Solver(program, {
     registry,
     isoStrict: options.isoStrict,
-    ioOptions: { write: (text) => process.stdout.write(String(text)) },
+    ioOptions: {
+      write: (text) => process.stdout.write(String(text)),
+      errorWrite: (text) => process.stderr.write(String(text)),
+    },
   });
   program = solver.program;
   const goals = engine.normalizeGoals(options.goals, solver);
@@ -252,6 +259,7 @@ Options:
                         reject EyeProlog language extensions and disable automatic tabling.
   --portable            Enforce the EyeProlog/Trealla/Scryer interop profile.
   --no-autoload         Disable conservative interop predicate autoloading.
+  --no-auto-table       Use traditional depth-first control instead of automatic recursive tabling.
   -v, --version         Show the package version and exit.
   -w, --warnings        Print non-fatal portability warnings to stderr.
   -g, --goal goal       Solve goal and print its ground answers; may be repeated.

package/src/io.js

@@ -64,6 +64,12 @@ export class StreamManager {
     this.add({ id: 1, alias: 'user_output', mode: 'append', type: 'text',
       content: '', position: 0, path: '', reposition: false,
       eofAction: 'reset', standard: true, write: this.output, pastEnd: false });
+    // user_error is a conventional de-facto standard stream used by the
+    // portable Scryer/Trealla libraries. Keep it on a negative internal handle
+    // so the first user-opened ISO stream retains its historical id 2.
+    this.add({ id: -1, alias: 'user_error', mode: 'append', type: 'text',
+      content: '', position: 0, path: '', reposition: false,
+      eofAction: 'reset', standard: true, write: options.errorWrite ?? this.output, pastEnd: false });
     this.currentInput = 0;
     this.currentOutput = 1;
   }

package/src/iso.js

@@ -581,19 +581,85 @@ function isPartialList(list, env) {
   return cursor.type === VAR;
 }
 
+const freshCopyGroundCache = new WeakMap();
+
+function structurallyVariableFree(term) {
+  if (term?.type === VAR) return false;
+  if (term?.type !== COMPOUND) return true;
+  const known = freshCopyGroundCache.get(term);
+  if (known !== undefined) return known;
+
+  const pending = [{ term, visited: false }];
+  while (pending.length > 0) {
+    const frame = pending.pop();
+    const current = frame.term;
+    if (current?.type !== COMPOUND || freshCopyGroundCache.has(current)) continue;
+    if (!frame.visited) {
+      pending.push({ term: current, visited: true });
+      for (let index = current.args.length - 1; index >= 0; index--) {
+        const child = current.args[index];
+        if (child?.type === COMPOUND && !freshCopyGroundCache.has(child)) {
+          pending.push({ term: child, visited: false });
+        }
+      }
+      continue;
+    }
+    let ground = true;
+    for (const child of current.args) {
+      if (child?.type === VAR || (child?.type === COMPOUND && freshCopyGroundCache.get(child) !== true)) {
+        ground = false;
+        break;
+      }
+    }
+    freshCopyGroundCache.set(current, ground);
+  }
+  return freshCopyGroundCache.get(term) === true;
+}
+
 function freshCopy(term, env, variables = new Map(), id = ++isoFresh) {
-  term = deref(term, env);
-  if (term.type === VAR) {
-    if (!variables.has(term.name)) variables.set(term.name, variable(`__copy${id}_${variables.size}`));
-    return variables.get(term.name);
+  const copyNode = (source) => {
+    if (source.type === VAR) {
+      if (!variables.has(source.name)) variables.set(source.name, variable(`__copy${id}_${variables.size}`));
+      return variables.get(source.name);
+    }
+    if (source.type !== COMPOUND) return source;
+    // Ground terms are immutable in EyeProlog. Sharing them is observably
+    // equivalent to copying and avoids rebuilding large lists for assertz/1,
+    // copy_term/2, bagof/findall storage, and exception terms.
+    if (structurallyVariableFree(source)) return source;
+    const copied = compound(source.name, new Array(source.args.length));
+    // Module qualification is execution context, not logical variable state.
+    // Preserve it across copy_term/2 so meta-predicate closures keep the caller
+    // module they received before a library copies and later invokes them.
+    if (source.module != null) copied.module = source.module;
+    return copied;
+  };
+
+  const source = deref(term, env);
+  const root = copyNode(source);
+  if (source.type !== COMPOUND || source.args.length === 0) return root;
+
+  // copy_term/2 is routinely used on long lists and large machine states.
+  // Traverse iteratively so term depth is independent of the host call stack.
+  // The map also preserves rational-tree cycles when occurs_check is disabled.
+  const copies = new Map([[source, root]]);
+  const pending = [{ source, target: root }];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    for (let index = 0; index < current.source.args.length; index++) {
+      const childSource = deref(current.source.args[index], env);
+      let child = childSource.type === COMPOUND ? copies.get(childSource) : null;
+      if (child == null) {
+        child = copyNode(childSource);
+        if (childSource.type === COMPOUND && child !== childSource) {
+          copies.set(childSource, child);
+          if (childSource.args.length > 0) pending.push({ source: childSource, target: child });
+        }
+      }
+      current.target.args[index] = child;
+    }
   }
-  if (term.type !== COMPOUND) return term;
-  const copied = compound(term.name, term.args.map((arg) => freshCopy(arg, env, variables, id)));
-  // Module qualification is execution context, not logical variable state.
-  // Preserve it across copy_term/2 so meta-predicate closures keep the caller
-  // module they received before a library copies and later invokes them.
-  if (term.module != null) copied.module = term.module;
-  return copied;
+  return root;
 }
 function* copyTermBuiltin({ goal, env }) {
   const next = env.clone();
@@ -609,13 +675,15 @@ function* termVariablesBuiltin({ goal, env }) {
   }
   const found = [];
   const seen = new Set();
-  const visit = (term) => {
-    term = deref(term, env);
+  const pending = [goal.args[0]];
+  while (pending.length > 0) {
+    const term = deref(pending.pop(), env);
     if (term.type === VAR) {
       if (!seen.has(term.name)) { seen.add(term.name); found.push(term); }
-    } else for (const arg of term.args) visit(arg);
-  };
-  visit(goal.args[0]);
+      continue;
+    }
+    for (let index = term.args.length - 1; index >= 0; index--) pending.push(term.args[index]);
+  }
   const next = env.clone();
   if (unify(goal.args[1], listFromItems(found), next)) yield next;
 }

package/src/lib/iso_ext.pl

@@ -28,8 +28,7 @@ call_nth(Goal, Nth) :- eyeprolog__call_nth(Goal, Nth).
 countall(Goal, Count) :- eyeprolog__countall(Goal, Count).
 
 forall(Condition, Action) :-
-    findall(Action, Condition, Actions),
-    iso_ext__call_all(Actions).
+    \+ (Condition, \+ Action).
 
 succ(X, S) :-
     var(X), !,

package/src/lib/random.pl

@@ -1,12 +1,13 @@
 /** Reproducible pseudo-random values.
 
     random/3 is EyeProlog's explicit-state interface.  maybe/0,
-    random_integer/3, and set_random/1 are the common Scryer/Trealla library
-    interface; they use a non-backtrackable seed while retaining the same
-    Park-Miller generator.
+    random/1, random_integer/3, and set_random/1 are the mutable-seed library
+    interface used for compatibility. random/1 uses EyeProlog's private native
+    state step for hot-loop performance; random/3 remains the portable explicit-
+    state Park-Miller generator, and both retain the same sequence.
 */
 
-:- module(random, [maybe/0, random/3, random_integer/3, set_random/1]).
+:- module(random, [maybe/0, random/1, random/3, random_integer/3, set_random/1]).
 
 :- use_module(library(debug), [bb_global_get/2, bb_put/2]).
 :- use_module(library(error), [instantiation_error/1, type_error/3]).
@@ -14,6 +15,10 @@
 maybe :-
     random_integer(0, 2, 0).
 
+
+random(Value) :-
+    eyeprolog__random_value(Value).
+
 random_integer(Lower, Upper, R) :-
     ( var(Lower) -> instantiation_error(random_integer/3)
     ; var(Upper) -> instantiation_error(random_integer/3)

package/src/program-indexing.js

@@ -86,13 +86,24 @@ export function clauseHasCut(clause) {
 }
 
 export function termContainsCut(term) {
-  if (term.type === ATOM) return term.name === '!';
-  return term.type === COMPOUND && term.args.some(termContainsCut);
+  const pending = [term];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    if (current?.type === ATOM && current.name === '!') return true;
+    if (current?.type !== COMPOUND) continue;
+    for (let index = current.args.length - 1; index >= 0; index--) pending.push(current.args[index]);
+  }
+  return false;
 }
 
 export function termHasNoVariables(term) {
-  if (!term || term.type === 'var') return false;
-  return !term.args?.some((arg) => !termHasNoVariables(arg));
+  const pending = [term];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    if (!current || current.type === 'var') return false;
+    for (let index = current.args?.length - 1 ?? -1; index >= 0; index--) pending.push(current.args[index]);
+  }
+  return true;
 }
 
 // These defaults mirror SWI-Prolog's JITI admission policy: small predicates
@@ -110,7 +121,51 @@ export function makeArgumentIndex() {
     numberBuckets: new Map(),
     fallback: [],
     sawScalar: false,
+    // Dynamic predicates often store fully-ground structured keys such as
+    // seen(answer(...)). Keep an exact structural hash alongside the scalar
+    // indexes so repeated membership checks do not scan every prior clause.
+    groundBuckets: new Map(),
+    groundFallback: [],
+    sawGround: false,
+  };
+}
+
+function groundTermIndexKey(term, env = null) {
+  // Use a compact structural hash instead of materializing the complete term
+  // spelling as a Map key. Dynamic bookkeeping predicates frequently store
+  // long ground lists; a fixed-size hash avoids retaining another full copy of
+  // every list merely for indexing. Hash collisions are harmless because the
+  // selected clauses are still matched normally by the solver.
+  let hash = 0x811c9dc5;
+  const mixCode = (code) => { hash = Math.imul(hash ^ code, 0x01000193) >>> 0; };
+  const mixString = (text) => {
+    for (let index = 0; index < text.length; index++) mixCode(text.charCodeAt(index));
+    mixCode(0xff);
   };
+  const stack = [term];
+  while (stack.length > 0) {
+    const raw = stack.pop();
+    const current = env == null ? raw : deref(raw, env);
+    if (current?.type === VAR) return null;
+    if (current?.type === COMPOUND) {
+      mixCode(1);
+      mixString(current.name);
+      mixCode(current.arity);
+      for (let index = current.args.length - 1; index >= 0; index--) stack.push(current.args[index]);
+      continue;
+    }
+    if (current?.type === 'number') {
+      mixCode(2);
+      mixString(numberValueKey(current.name));
+    } else if (current?.type === 'string') {
+      mixCode(3);
+      mixString(String(current.name));
+    } else {
+      mixCode(4);
+      mixString(String(current?.name ?? ''));
+    }
+  }
+  return hash;
 }
 
 function scalarBuckets(index, term) {
@@ -168,7 +223,7 @@ export function indexCompactOne(index, type, name, clause, clauses = null, claus
   }
 }
 
-export function indexOne(index, arg, clause, clauses = null, clausePosition = -1) {
+export function indexOne(index, arg, clause, clauses = null, clausePosition = -1, indexGround = false) {
   if (isScalar(arg)) {
     if (!index.sawScalar) {
       index.sawScalar = true;
@@ -178,6 +233,18 @@ export function indexOne(index, arg, clause, clauses = null, clausePosition = -1
   } else if (index.sawScalar) {
     index.fallback.push(clause);
   }
+
+  if (!indexGround) return;
+  const groundKey = groundTermIndexKey(arg);
+  if (groundKey != null) {
+    if (!index.sawGround) {
+      index.sawGround = true;
+      if (clauses && clausePosition > 0) index.groundFallback = clauses.slice(0, clausePosition);
+    }
+    addClauseBucket(index.groundBuckets, groundKey, clause);
+  } else if (index.sawGround) {
+    index.groundFallback.push(clause);
+  }
 }
 
 function indexFallback(index, group) {
@@ -204,7 +271,9 @@ export function rebuildGroupIndexes(group) {
     clause.scalarHead = clause.head.type === COMPOUND && clause.head.args.every(isScalar);
     if (clauseHasCut(clause)) group.hasCut = true;
     if (clause.body.length !== 0 || !clause.scalarHead) group.scalarFactsOnly = false;
-    for (let i = 0; i < group.arity; i++) indexOne(group.argIndexes[i], clause.head.args[i], clause, group.clauses, clausePosition);
+    for (let i = 0; i < group.arity; i++) {
+      indexOne(group.argIndexes[i], clause.head.args[i], clause, group.clauses, clausePosition, group.dynamic === true);
+    }
   }
 }
 
@@ -301,15 +370,36 @@ export function selectClauseCandidates(group, goal, env) {
   }
   const positions = [];
   const values = [];
+  let bestGround = null;
+  let bestGroundLength = group.clauses.length;
   for (let i = 0; i < goal.arity; i++) {
     const arg = deref(goal.args[i], env);
-    if (!isScalar(arg)) continue;
-    positions.push(i);
-    values.push(arg);
+    if (isScalar(arg)) {
+      positions.push(i);
+      values.push(arg);
+      continue;
+    }
+    const index = group.argIndexes[i];
+    if (!index?.sawGround) continue;
+    const key = groundTermIndexKey(arg, env);
+    if (key == null) continue;
+    const primary = index.groundBuckets.get(key) ?? null;
+    const fallback = index.groundFallback;
+    const length = clauseCollectionLength(primary) + fallback.length;
+    if (length < bestGroundLength) {
+      bestGround = fallback.length === 0 ? (primary ?? [])
+        : clauseCollectionLength(primary) === 0 ? fallback
+          : mergeClausesInSourceOrder(primary, fallback);
+      bestGroundLength = length;
+    }
   }
-  if (positions.length === 0) return { primary: group.clauses, fallback: [] };
-
-  return selectClauseCandidatesForValues(group, positions, values);
+  const scalarParts = positions.length === 0 ? null : selectClauseCandidatesForValues(group, positions, values);
+  const scalarLength = scalarParts == null
+    ? group.clauses.length
+    : clauseCollectionLength(scalarParts.primary) + scalarParts.fallback.length;
+  if (bestGround != null && bestGroundLength < scalarLength) return { primary: bestGround, fallback: [] };
+  if (scalarParts != null) return scalarParts;
+  return { primary: group.clauses, fallback: [] };
 }
 
 // The scalar-fact join already has dereferenced local values. Keeping this

package/src/program.js

@@ -85,6 +85,9 @@ export class Program {
     this.multifilePredicates = new Set();
     this.discontiguousPredicates = new Set();
     this.strictIso = options.isoStrict === true;
+    // Normal mode automatically tables recursive user predicates unless an
+    // embedder explicitly requests traditional depth-first Prolog control.
+    this.autoTabling = options.autoTabling !== false;
     this.operators = new Map();
     const predefinedOperatorSets = this.strictIso
       ? [ISO_OPERATOR_DEFINITIONS]
@@ -177,7 +180,9 @@ export class Program {
     group.clauses.push(clause);
     if (clauseHasCut(clause)) group.hasCut = true;
     const clausePosition = group.clauses.length - 1;
-    for (let i = 0; i < head.arity; i++) indexOne(group.argIndexes[i], head.args[i], clause, group.clauses, clausePosition);
+    for (let i = 0; i < head.arity; i++) {
+      indexOne(group.argIndexes[i], head.args[i], clause, group.clauses, clausePosition, group.dynamic === true);
+    }
   }
   findGroup(name, arity, module = 'user') {
     const indicator = `${name}/${arity}`;
@@ -255,9 +260,24 @@ export class Program {
     clause.groundHead = termHasNoVariables(clause.head);
     clause.scalarHead = clause.head.type === COMPOUND && clause.head.args.every(isScalar);
     this.clauses.push(clause);
-    if (atStart) group.clauses.unshift(clause);
-    else group.clauses.push(clause);
-    rebuildGroupIndexes(group);
+    if (atStart) {
+      group.clauses.unshift(clause);
+      rebuildGroupIndexes(group);
+    } else {
+      const clausePosition = group.clauses.length;
+      group.clauses.push(clause);
+      // assertz/1 is by far the common dynamic-update path. Appending a clause
+      // does not invalidate the existing argument buckets, so extend them in
+      // place instead of rebuilding the whole predicate after every insert.
+      // This changes repeated ground bookkeeping from quadratic to linear.
+      group.demandIndexes.clear();
+      group.rejectedDemandIndexes.clear();
+      if (clause.body.length !== 0 || !clause.scalarHead) group.scalarFactsOnly = false;
+      if (clauseHasCut(clause)) group.hasCut = true;
+      for (let i = 0; i < clause.head.arity; i++) {
+        indexOne(group.argIndexes[i], clause.head.args[i], clause, group.clauses, clausePosition, true);
+      }
+    }
     this.noteMutation(clause.body.length > 0);
   }
   removeDynamicClause(group, clause) {
@@ -378,7 +398,7 @@ export class Program {
       );
       group.listTailRecursive = directRecursiveComponent && !group.cutRecursive &&
         hasStrictListTailRecursion(group);
-      group.tabled = plannedRecursive &&
+      group.tabled = this.autoTabling && plannedRecursive &&
         !componentHasNegativeEdge(start, deps, negativeEdges) &&
         !group.cutRecursive &&
         !linearNumeric;
@@ -698,7 +718,7 @@ class ProgramBuilder {
         if (clauseHasCut(clause)) group.hasCut = true;
         if (clause.body.length !== 0 || !clause.scalarHead) group.scalarFactsOnly = false;
         for (let i = 0; i < head.arity; i++) {
-          indexOne(group.argIndexes[i], head.args[i], clause, group.clauses, clausePosition);
+          indexOne(group.argIndexes[i], head.args[i], clause, group.clauses, clausePosition, group.dynamic === true);
         }
         continue;
       }
@@ -780,11 +800,13 @@ class ProgramBuilder {
 }
 
 function buildProgramFromSources(sources, options) {
-  // The source-metadata-free path is common for CLI and conformance runs.  It
-  // attempts the compact line parser directly into a fresh builder.  Should a
-  // source require the full parser (for example because it defines custom
-  // operators), the partial builder is simply discarded and the source set is
-  // rebuilt once with the general streaming parser.
+  // The source-metadata-free path is common for CLI and conformance runs. For
+  // a homogeneous source set, first try the compact parser directly into a
+  // fresh builder. Source sets that contain module-loading directives use a
+  // hybrid path instead: directive-heavy sources take the general parser while
+  // independent fast-compatible sources can still keep their compact clauses.
+  // This matters for launchers that load a small support program followed by a
+  // very large ordinary fact/rule file.
   const hasModuleDirectives = sources.some((source) => {
     const text = typeof source === 'string' ? source : source?.text ?? source?.source ?? '';
     return /:-\s*(?:module|use_module)\s*\(/.test(text);
@@ -793,12 +815,47 @@ function buildProgramFromSources(sources, options) {
     const builder = new ProgramBuilder(options);
     if (loadSourcesIntoBuilder(builder, sources, options, true)) return builder.finish();
   }
+  if (options.sourceMetadata === false && hasModuleDirectives) {
+    const builder = new ProgramBuilder(options);
+    if (loadSourcesIntoBuilder(builder, sources, options, 'hybrid')) return builder.finish();
+  }
 
   const builder = new ProgramBuilder(options);
   loadSourcesIntoBuilder(builder, sources, options, false);
   return builder.finish();
 }
 
+function cloneOperatorState(state) {
+  return {
+    infixOperators: new Map(state.infixOperators),
+    prefixOperators: new Map(state.prefixOperators),
+    postfixOperators: new Map(state.postfixOperators),
+  };
+}
+
+function cloneParserFlagState(state) {
+  return {
+    doubleQuotes: state.doubleQuotes,
+    charConversion: state.charConversion,
+    charConversions: new Map(state.charConversions),
+  };
+}
+
+function hybridFastSource(source, options) {
+  // Module/include directives recurse into additional source texts and can
+  // change lexical context. Keep those sources on the general loader. Ordinary
+  // user files may still contain op/3, dynamic/1, discontiguous/1, etc.; the
+  // compact parser handles those term-by-term and updates the shared state.
+  if (/:-(?:\s|\/\*[\s\S]*?\*\/)*(?:module|use_module|include|ensure_loaded)\s*\(/.test(source)) return false;
+  const probeOptions = {
+    ...options,
+    operatorState: cloneOperatorState(options.operatorState),
+    parserFlagState: cloneParserFlagState(options.parserFlagState),
+    onWarning: null,
+  };
+  return tryParseClausesFastInto(source, () => {}, () => {}, probeOptions);
+}
+
 // Program.parse() can see host-supplied goals through autoloadGoals while it
 // builds the program. A Program passed directly to run() has already completed
 // that phase, so extend the existing instance with the same canonical interop
@@ -863,7 +920,8 @@ function loadSourcesIntoBuilder(builder, sources, options, fast) {
         module: 'user',
         textUnit: sourcePath(item.options) ?? `<input:${sourceIndex}>`,
       };
-      if (!loadSourceIntoBuilder(builder, text, item.options, ensured, loadedModules, fast, context)) return false;
+      const sourceFast = fast === 'hybrid' ? hybridFastSource(text, item.options) : fast;
+      if (!loadSourceIntoBuilder(builder, text, item.options, ensured, loadedModules, sourceFast, context)) return false;
     }
     const autoloadGoals = parseInteropGoalInputs(options.autoloadGoals, {
       ...options,

package/src/scryer-compat.js

@@ -4,7 +4,7 @@
 // backtrackable blackboard lives in Env so ordinary Prolog choice points undo
 // writes automatically.
 
-import { ATOM, COMPOUND, NUMBER, STRING, VAR, atom, compound, deref, listFromItems, unify } from './term.js';
+import { ATOM, COMPOUND, NUMBER, STRING, VAR, atom, compound, deref, listFromItems, numberTerm, numberTextFromDouble, unify } from './term.js';
 import { PrologError } from './errors.js';
 import { formatTermForWrite } from './write.js';
 
@@ -46,6 +46,27 @@ function* bbGlobalPutBuiltin({ solver, goal, env }) {
   yield env;
 }
 
+
+
+function* randomValueBuiltin({ solver, goal, env }) {
+  const key = 'a:$random_seed';
+  const stored = solver.nonBacktrackableBlackboard.get(key);
+  let seed = stored == null ? 1 : Number(deref(stored, env).name);
+  if (!Number.isSafeInteger(seed)) seed = 1;
+  seed %= 2147483647;
+  if (seed < 0) seed += 2147483647;
+  if (seed === 0) seed = 1;
+  const high = Math.floor(seed / 44488);
+  const low = seed % 44488;
+  let nextSeed = 48271 * low - 3399 * high;
+  if (nextSeed <= 0) nextSeed += 2147483647;
+  const value = (nextSeed - 1) / 2147483646;
+  const next = env.clone();
+  if (!unify(goal.args[0], numberTerm(numberTextFromDouble(value)), next)) return;
+  solver.nonBacktrackableBlackboard.set(key, numberTerm(nextSeed));
+  yield next;
+}
+
 const charTypeNames = new Set([
   'alnum', 'alpha', 'alphabetic', 'alphanumeric', 'ascii', 'ascii_graphic',
   'ascii_punctuation', 'binary_digit', 'control', 'decimal_digit', 'exponent',
@@ -215,15 +236,34 @@ function* termCharsBuiltin({ solver, goal, env }) {
   if (unify(goal.args[2], chars(text), next)) yield next;
 }
 
+
+function* portrayClauseBuiltin({ solver, goal, env }) {
+  const text = formatTermForWrite(goal.args[0], env, {
+    quoted: true,
+    numbervars: true,
+    compact: true,
+    minimalOperatorSpacing: true,
+    operatorAtomsAsArgs: true,
+    generateVariableNames: true,
+    variableNameState: solver.writeVariableState,
+    operators: solver.program.operators.values(),
+  });
+  const stream = solver.io.resolve(solver.io.currentOutput);
+  solver.io.writeUnit(stream, `${text}.\n`);
+  yield env;
+}
+
 export const scryerCompatibilityBuiltins = {
   register(registry) {
     registry.add('eyeprolog__bb_get', 2, bbGetBuiltin, { deterministic: true, eyePrologLibrary: true });
     registry.add('eyeprolog__bb_b_put', 2, bbPutBuiltin, { deterministic: true, eyePrologLibrary: true });
     registry.add('eyeprolog__bb_global_get', 2, bbGlobalGetBuiltin, { deterministic: true, eyePrologLibrary: true });
     registry.add('eyeprolog__bb_global_put', 2, bbGlobalPutBuiltin, { deterministic: true, eyePrologLibrary: true });
+    registry.add('eyeprolog__random_value', 1, randomValueBuiltin, { deterministic: true, eyePrologLibrary: true });
     registry.add('eyeprolog__char_type', 2, charTypeBuiltin, { eyePrologLibrary: true });
     registry.add('eyeprolog__current_time', 1, currentTimeBuiltin, { deterministic: true, eyePrologLibrary: true });
     registry.add('eyeprolog__abolish_all_tables', 0, abolishAllTablesBuiltin, { deterministic: true, eyePrologLibrary: true });
     registry.add('eyeprolog__term_chars', 3, termCharsBuiltin, { deterministic: true, eyePrologLibrary: true });
+    registry.add('portray_clause', 1, portrayClauseBuiltin, { deterministic: true, eyePrologLibrary: true });
   },
 };

package/src/solver.js

@@ -17,6 +17,7 @@ import { evaluatePositiveDatalog, relationForDatalogGroup, datalogCandidateIndex
 
 let freshCounter = 0;
 const DEFAULT_INNER_TABLE_SCOPE_LIMIT = 1024;
+const GOAL_CONTINUATION_THRESHOLD = 64;
 // Conservative live-storage estimate for one generated length/2 list cell
 // (cons object, argument vector, fresh variable, and its generated name).
 const GENERATED_LENGTH_CELL_RESERVE_BYTES = 256;
@@ -438,8 +439,22 @@ export class Solver {
       if (frame.kind === 'userClause') {
         if (this.solutionsSeen >= this.solutionLimit) continue;
         const { clause, goal: clauseGoal, rest: clauseRest, env: clauseEnv, depth: clauseDepth,
-          active: clauseActive, release } = frame;
+          active: clauseActive, release, tailReleaseBeforeLast, directCutReleaseIndex } = frame;
         let next;
+        if (clause.body.length === 0 && clause.groundHead) {
+          const matched = sameResolvedGroundTerm(clauseGoal, clause.head, clauseEnv);
+          if (matched === true) {
+            stack.push({
+              kind: 'goals',
+              goals: [...release, ...clauseRest],
+              env: clauseEnv,
+              depth: clauseDepth + 1,
+              active: clauseActive,
+            });
+            continue;
+          }
+          if (matched === false) continue;
+        }
         if (clause.body.length === 0 && clause.scalarHead) {
           next = matchScalarFact(clauseGoal, clause.head, clauseEnv);
           if (!next) continue;
@@ -463,11 +478,33 @@ export class Solver {
         next = clauseEnv.clone();
         this.stats.unify_calls++;
         if (!unify(clauseGoal, freshHead, next, { knownNonoccurringVariables: headLocalFresh })) continue;
+        let nextGoals;
+        if (freshBody.length === 0) {
+          nextGoals = [...release, ...clauseRest];
+        } else if (directCutReleaseIndex >= 0) {
+          const afterCut = directCutReleaseIndex + 1;
+          nextGoals = [...freshBody.slice(0, afterCut), ...release, ...freshBody.slice(afterCut), ...clauseRest];
+        } else if (tailReleaseBeforeLast) {
+          const tail = freshBody[freshBody.length - 1];
+          next.compactForDeepContinuation?.();
+          nextGoals = [...freshBody.slice(0, -1), ...release, tail, ...clauseRest];
+        } else if (clauseRest.length >= GOAL_CONTINUATION_THRESHOLD ||
+            clauseRest.some((goal) => goal?.kind === 'continueGoals')) {
+          // Keep a large caller continuation as one opaque frame instead of
+          // copying its complete pending goal list into every nested clause.
+          // Small goal lists remain flat because that representation is faster
+          // for ordinary shallow search.
+          next.compactForDeepContinuation?.();
+          nextGoals = [
+            ...freshBody,
+            { kind: 'continueGoals', goals: clauseRest, depth: clauseDepth, releaseActive: release.length !== 0 },
+          ];
+        } else {
+          nextGoals = [...freshBody, ...release, ...clauseRest];
+        }
         stack.push({
           kind: 'goals',
-          goals: freshBody.length === 0
-            ? [...release, ...clauseRest]
-            : [...freshBody, ...release, ...clauseRest],
+          goals: nextGoals,
           env: next,
           depth: clauseDepth + 1,
           active: clauseActive,
@@ -552,6 +589,12 @@ export class Solver {
         }
 
         const first = goals[0];
+        if (first?.kind === 'continueGoals') {
+          if (first.releaseActive) active = active.slice(0, -1);
+          depth = first.depth;
+          goals = first.goals;
+          continue;
+        }
         if (first?.kind === 'releaseActive') {
           active = active.slice(0, -1);
           goals = goals.slice(1);
@@ -987,7 +1030,7 @@ export class Solver {
   }
 
   *solveUserGoalUncached(group, goal, rest, env, depth) {
-    if (group.recursive && !group.cutRecursive && !group.linearNumeric && this.activeVariant(goal, env)) {
+    if (this.program.autoTabling !== false && group.recursive && !group.cutRecursive && !group.linearNumeric && this.activeVariant(goal, env)) {
       this.recursionCycleDetected = true;
       return;
     }
@@ -1194,7 +1237,7 @@ 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)) {
+  if (solver.program.autoTabling !== false && group.recursive && !group.cutRecursive && !group.linearNumeric && activeVariantIn(goal, env, active)) {
     solver.recursionCycleDetected = true;
     return;
   }
@@ -1208,9 +1251,6 @@ function pushUserGoalUncachedFrames(stack, solver, group, goal, rest, env, depth
   // recursive user predicates. Cut-free, non-recursive library helpers need
   // neither. Copying their full active stack at every recursive step made
   // otherwise linear relations such as length/2 retain O(depth^2) references.
-  const guarded = groupNeedsActiveFrame(group);
-  const release = guarded ? [{ kind: 'releaseActive' }] : [];
-  const nextActive = guarded ? [...active, invocation] : active;
   for (const pass of [candidates.primary, candidates.fallback]) {
     for (let candidateIndex = 0; candidateIndex < clauseCandidateLength(pass); candidateIndex++) {
       const clause = clauseCandidateAt(pass, candidateIndex);
@@ -1226,11 +1266,26 @@ function pushUserGoalUncachedFrames(stack, solver, group, goal, rest, env, depth
         rest,
         env,
         depth,
-        active: nextActive,
-        release,
       });
     }
   }
+  // Traditional depth-first mode disables recursive-cycle guards. A cut
+  // boundary is then needed only if an actually reachable clause contains a
+  // cut. Scalar indexes often narrow a mixed predicate to one cut-free
+  // recursive clause; do not copy the whole active path at every such layer.
+  const guarded = solver.program.autoTabling === false
+    ? frames.some((frame) => clauseHasCutForTailRelease(frame.clause))
+    : groupNeedsActiveFrame(group);
+  const release = guarded ? [{ kind: 'releaseActive' }] : [];
+  const nextActive = guarded ? [...active, invocation] : active;
+  for (const frame of frames) {
+    frame.active = nextActive;
+    frame.release = release;
+    frame.tailReleaseBeforeLast = solver.program.autoTabling === false && guarded &&
+      clauseCanReleaseActiveBeforeTailCall(group, frame.clause);
+    frame.directCutReleaseIndex = solver.program.autoTabling === false && guarded
+      ? clauseDirectCutReleaseIndex(frame.clause) : -1;
+  }
   for (let i = frames.length - 1; i >= 0; i--) stack.push(frames[i]);
 }
 
@@ -1363,6 +1418,51 @@ function prepareLocalVariablesForGoal(goal, env) {
   env.markLocalVariables(goal?._localFirstUseVariables ?? null);
 }
 
+function clauseDirectCutReleaseIndex(clause) {
+  if (clause?.compactBinary === true) return -1;
+  let lastDirectCut = -1;
+  for (let index = 0; index < clause.body.length; index++) {
+    const goal = clause.body[index];
+    if (goal?.type === ATOM && goal.name === '!') {
+      lastDirectCut = index;
+      continue;
+    }
+    if (termContainsCutForRelease(goal)) return -1;
+  }
+  return lastDirectCut;
+}
+
+function termContainsCutForRelease(term) {
+  if (term?.type === ATOM) return term.name === '!';
+  if (term?.type !== COMPOUND) return false;
+  const pending = [...term.args];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    if (current?.type === ATOM && current.name === '!') return true;
+    if (current?.type === COMPOUND) for (const arg of current.args) pending.push(arg);
+  }
+  return false;
+}
+
+function clauseCanReleaseActiveBeforeTailCall(group, clause) {
+  if (clauseHasCutForTailRelease(clause)) return false;
+  if (group.clauses[group.clauses.length - 1] !== clause || clause.body.length === 0) return false;
+  const tail = clause.body[clause.body.length - 1];
+  return tail?.type === COMPOUND && tail.name === group.name && tail.arity === group.arity &&
+    (tail.module ?? group.module) === group.module;
+}
+
+function clauseHasCutForTailRelease(clause) {
+  if (clause?.compactBinary === true) return false;
+  const pending = [...clause.body];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    if (current?.type === ATOM && current.name === '!') return true;
+    if (current?.type === COMPOUND) for (const arg of current.args) pending.push(arg);
+  }
+  return false;
+}
+
 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
@@ -2174,7 +2274,7 @@ function tryPushScalarFactRunFrames(stack, solver, goals, env, depth, active) {
   const groups = [];
   while (runLength < goals.length) {
     const goal = goals[runLength];
-    if (!goal || goal.kind === 'releaseActive' || goal.kind === 'memoStore') break;
+    if (!goal || goal.kind === 'releaseActive' || goal.kind === 'memoStore' || goal.kind === 'continueGoals') break;
     if (goal.type !== COMPOUND) break;
     const def = solver.registry.get(goal.name, goal.arity);
     if (def) break;
@@ -2214,7 +2314,7 @@ 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)) {
+    if (solver.program.autoTabling !== false && activeMightContain(goal, active) && activeVariantIn(goal, envWithLocal(env, state.names, state.values), active)) {
       solver.recursionCycleDetected = true;
       continue;
     }
@@ -2274,7 +2374,7 @@ function* scalarFactRunGenerator(solver, goals, groups, env, depth, active, pend
     }
 
     const goal = goals[state.index];
-    if (activeMightContain(goal, active) && activeVariantIn(goal, envWithLocal(env, state.names, state.values), active)) {
+    if (solver.program.autoTabling !== false && activeMightContain(goal, active) && activeVariantIn(goal, envWithLocal(env, state.names, state.values), active)) {
       solver.recursionCycleDetected = true;
       continue;
     }
@@ -2433,19 +2533,72 @@ function compactIndexBucket(index, type, name) {
 }
 
 function tryPushCompactBinaryChainFrames(stack, solver, group, goal, rest, env, depth, active) {
-  if (active.length !== 0 || goal.type !== COMPOUND || goal.arity !== 2) return false;
-  // This fast path only accepts scalar arguments. Dereference those arguments
-  // directly instead of deep-copying the whole goal before discovering that a
-  // list/compound argument is ineligible. Besides avoiding wasted work, this
-  // keeps deep DCG state lists away from recursive copyResolved().
+  if (goal.type !== COMPOUND || goal.arity !== 2) return false;
+  // This fast path follows deterministic compact binary chains selected by a
+  // scalar second argument. In addition to a scalar first argument, accept an
+  // unbound first variable when every recursive rule carries that variable
+  // through unchanged. The latter is the common taxonomy form p(X,nN) :-
+  // p(X,nN-1): it can be walked iteratively and X is bound only by the base
+  // fact, avoiding thousands of recursive Env/active-frame allocations.
   const first = derefForLocal(goal.args[0], env);
   const second = derefForLocal(goal.args[1], env);
-  let secondType = second?.type;
-  let secondName = second?.name;
-  if (!isScalarTerm(first) || !['atom', 'string', 'number'].includes(secondType)) return false;
+  const firstScalar = isScalarTerm(first);
+  const firstVariable = first?.type === 'var';
+  if ((!firstScalar && !firstVariable) || !['atom', 'string', 'number'].includes(second?.type)) return false;
+  // Preserve the established cached scalar-chain semantics inside an active
+  // invocation. The variable-carry chain below does not use cross-call caches
+  // and is safe in an active meta-call because it still checks its own cycles.
+  if (firstScalar && active.length !== 0) return false;
 
   const index = group.argIndexes[1];
   if (!index?.sawScalar || index.fallback.length !== 0) return false;
+
+  if (firstVariable) {
+    const seen = scalarSetContainer();
+    let secondType = second.type;
+    let secondName = second.name;
+    let currentDepth = depth;
+    while (true) {
+      if (solver.solutionsSeen >= solver.solutionLimit) return true;
+      solver.stats.max_depth = Math.max(solver.stats.max_depth, currentDepth);
+      const seenSet = seen[secondType];
+      if (!seenSet) return true;
+      if (seenSet.has(secondName)) {
+        solver.recursionCycleDetected = true;
+        return true;
+      }
+      seenSet.add(secondName);
+
+      const candidates = compactIndexBucket(index, secondType, secondName);
+      if (clauseCandidateLength(candidates) !== 1) return false;
+      const clause = clauseCandidateAt(candidates, 0);
+      if (clause?.compactBinary !== true || clause.headName !== group.name) return false;
+      if (clause.head1Type !== secondType || clause.head1Name !== secondName) return true;
+
+      if (clause.bodyName == null) {
+        const next = env.clone();
+        // A variable base fact leaves the carried query variable unconstrained;
+        // a scalar base fact binds it exactly as ordinary clause unification.
+        if (clause.head0Type !== 'var') {
+          if (!unify(goal.args[0], clause.head.args[0], next)) return true;
+          if (next._variableConstraints != null && !next.validateVariableConstraints()) return true;
+        }
+        stack.push({ kind: 'goals', goals: rest, env: next, depth: depth + 1, active });
+        return true;
+      }
+
+      if (clause.bodyName !== group.name || clause.head0Type !== 'var' ||
+          clause.body0Type !== 'var' || clause.body0Name !== clause.head0Name ||
+          !['atom', 'string', 'number'].includes(clause.body1Type)) return false;
+
+      secondType = clause.body1Type;
+      secondName = clause.body1Name;
+      currentDepth++;
+    }
+  }
+
+  let secondType = second.type;
+  let secondName = second.name;
   const cache = compactChainCacheFor(solver, group, first);
   const seen = scalarSetContainer();
   let currentDepth = depth;
@@ -2590,7 +2743,7 @@ function tryPushGroundChainFrames(stack, solver, group, goal, rest, env, depth,
       solver.recursionCycleDetected = true;
       return true;
     }
-    if (activeVariantIn(currentGoal, currentEnv, active)) {
+    if (solver.program.autoTabling !== false && activeVariantIn(currentGoal, currentEnv, active)) {
       solver.recursionCycleDetected = true;
       return true;
     }
@@ -2741,11 +2894,30 @@ function sameScalarTerm(left, right) {
 }
 
 function sameGroundTerm(left, right) {
-  if (left?.type !== right?.type) return false;
-  if (left?.type === 'number' ? !sameNumberValue(left.name, right.name) : left?.name !== right?.name) return false;
-  const arity = left.args?.length ?? 0;
-  if (arity !== (right.args?.length ?? 0)) return false;
-  for (let i = 0; i < arity; i++) if (!sameGroundTerm(left.args[i], right.args[i])) return false;
+  const pending = [[left, right]];
+  while (pending.length > 0) {
+    const [a, b] = pending.pop();
+    if (a?.type !== b?.type) return false;
+    if (a?.type === 'number' ? !sameNumberValue(a.name, b.name) : a?.name !== b?.name) return false;
+    const arity = a?.args?.length ?? 0;
+    if (arity !== (b?.args?.length ?? 0)) return false;
+    for (let index = 0; index < arity; index++) pending.push([a.args[index], b.args[index]]);
+  }
+  return true;
+}
+
+function sameResolvedGroundTerm(left, right, env) {
+  const pending = [[left, right]];
+  while (pending.length > 0) {
+    let [a, b] = pending.pop();
+    a = derefForLocal(a, env);
+    if (a?.type === 'var') return null;
+    if (a?.type !== b?.type) return false;
+    if (a?.type === 'number' ? !sameNumberValue(a.name, b.name) : a?.name !== b?.name) return false;
+    const arity = a?.args?.length ?? 0;
+    if (arity !== (b?.args?.length ?? 0)) return false;
+    for (let index = 0; index < arity; index++) pending.push([a.args[index], b.args[index]]);
+  }
   return true;
 }
 
@@ -2908,7 +3080,7 @@ function pushResumeBuiltinFrame(stack, iterator, goals, depth, active) {
 function selectReadyDeterministicBuiltin(goals, env, registry) {
   for (let i = 0; i < goals.length; i++) {
     const goal = goals[i];
-    if (goal?.kind === 'releaseActive' || goal?.kind === 'memoStore') return 0;
+    if (goal?.kind === 'releaseActive' || goal?.kind === 'memoStore' || goal?.kind === 'continueGoals') return 0;
     // A first-use proof is derived from source goal order. Do not move a later
     // deterministic builtin across that equality: doing so could touch one of
     // its proven-fresh variables before the checked binding executes.

package/src/standard-library.js

@@ -84,6 +84,7 @@ export const eyePrologNativeLibraryIndicators = Object.freeze([
   'disjoint2/1', 'automaton/3', 'automaton/8', 'chain/2', 'element/3', 'zcompare/3',
   'fd_var/1', 'fd_inf/2', 'fd_sup/2', 'fd_size/2', 'fd_dom/2',
   'clpz_t/2', '#=/3', '#</3',
+  'random/1',
 ]);
 export const eyePrologPortableLibraryIndicators = Object.freeze([
   'sumall/3', 'aggregate_min/5', 'aggregate_max/5',
@@ -232,7 +233,7 @@ const eyePrologSharedLibraryIndicators = [
   'ord_subtract/3', 'ord_symdiff/3', 'ord_union/2', 'ord_union/3', 'ord_union/4',
   'phrase_from_file/2', 'phrase_from_file/3', 'phrase_to_file/2',
   'phrase_to_file/3', 'phrase_to_stream/2',
-  'maybe/0', 'random_integer/3', 'set_random/1',
+  'maybe/0', 'random/1', 'random_integer/3', 'set_random/1',
   ',/3', ';/3', '=/3', 'cond_t/3', 'dif/3', 'if_/3', 'memberd_t/3',
   'tfilter/3', 'tmember/2', 'tmember_t/3', 'tpartition/4',
   'start_tabling/2', 'abolish_all_tables/0', 'current_time/1', 'format_time/4',

package/src/term.js

@@ -13,7 +13,7 @@ const EMPTY_ARGS = Object.freeze([]);
 // the chain into its indexed Map before that lookup cost dominates. Ordinary
 // execution keeps the memory-friendly 512-layer threshold; attributed-variable
 // propagation uses 256 because its repeated negative lookups dominate sooner.
-const ENV_FLATTEN_DEPTH = 512;
+const ENV_FLATTEN_DEPTH = 256;
 const ATTRIBUTED_ENV_FLATTEN_DEPTH = 256;
 // Runtime terms are structurally immutable: environments hold bindings beside
 // them rather than rewriting their argument arrays. Cache only the syntactic
@@ -105,6 +105,7 @@ export class Env {
       bindingValue: undefined,
       parent: null,
       depth: 0,
+      segmentCount: 0,
       cacheName: null,
       cacheValue: undefined,
       cache: null,
@@ -318,29 +319,55 @@ export class Env {
     }
     return undefined;
   }
+  compactForDeepContinuation(segmentLimit = 16) {
+    if ((this._state.segmentCount ?? 0) < segmentLimit) return false;
+    const flattened = new Map();
+    for (let state = this._state; state != null; state = state.parent) {
+      if (state.bindingName != null && !flattened.has(state.bindingName)) {
+        flattened.set(state.bindingName, state.bindingValue);
+      }
+      if (state.bindings) {
+        for (const [key, value] of state.bindings) {
+          if (!flattened.has(key)) flattened.set(key, value);
+        }
+      }
+    }
+    this._state = {
+      bindings: flattened,
+      bindingName: null,
+      bindingValue: undefined,
+      parent: null,
+      depth: 0,
+      segmentCount: 0,
+      cacheName: null,
+      cacheValue: undefined,
+      cache: null,
+    };
+    return true;
+  }
   bind(name, term) {
     const flattenDepth = this._prologAttributes == null
       ? ENV_FLATTEN_DEPTH
       : ATTRIBUTED_ENV_FLATTEN_DEPTH;
     if (this._state.depth >= flattenDepth) {
-      const flattened = new Map();
-      for (let state = this._state; state != null; state = state.parent) {
-        if (state.bindingName != null && !flattened.has(state.bindingName)) {
-          flattened.set(state.bindingName, state.bindingValue);
-        }
-        if (state.bindings) {
-          for (const [key, value] of state.bindings) {
-            if (!flattened.has(key)) flattened.set(key, value);
-          }
+      // Compact only the newest single-binding segment. Older compacted
+      // segments remain linked as parents, so deep deterministic recursion
+      // never recopies its complete binding history at every threshold.
+      const segment = new Map([[name, term]]);
+      let state = this._state;
+      while (state != null && state.bindings == null) {
+        if (state.bindingName != null && !segment.has(state.bindingName)) {
+          segment.set(state.bindingName, state.bindingValue);
         }
+        state = state.parent;
       }
-      flattened.set(name, term);
       this._state = {
-        bindings: flattened,
+        bindings: segment,
         bindingName: null,
         bindingValue: undefined,
-        parent: null,
+        parent: state,
         depth: 0,
+        segmentCount: (state?.segmentCount ?? 0) + 1,
         cacheName: null,
         cacheValue: undefined,
         cache: null,
@@ -353,6 +380,7 @@ export class Env {
       bindingValue: term,
       parent: this._state,
       depth: this._state.depth + 1,
+      segmentCount: this._state.segmentCount ?? 0,
       cacheName: null,
       cacheValue: undefined,
       cache: null,
@@ -923,12 +951,40 @@ export function freshTerm(term, suffix, variables = new Map()) {
 }
 
 export function copyResolved(term, env) {
+  const makeCopy = (resolved) => {
+    if (resolved.type === VAR) return variable(resolved.name);
+    const copied = resolved.type === COMPOUND && resolved.arity === 0
+      ? atom(resolved.name)
+      : new Term(resolved.type, resolved.name, new Array(resolved.args.length));
+    if (resolved.module != null) copied.module = resolved.module;
+    return copied;
+  };
+
   const resolved = deref(term, env);
-  if (resolved.type === VAR) return variable(resolved.name);
-  const copied = resolved.type === COMPOUND && resolved.arity === 0
-    ? atom(resolved.name)
-    : new Term(resolved.type, resolved.name, resolved.args.map((arg) => copyResolved(arg, env)));
-  if (resolved.module != null) copied.module = resolved.module;
+  const copied = makeCopy(resolved);
+  if (resolved.type === VAR || resolved.args.length === 0) return copied;
+
+  // Deep lists and machine-state terms can contain thousands of nested cells.
+  // Copy them iteratively so readback never consumes the JavaScript call stack.
+  // Keep a source-to-copy map as well, both to preserve shared subterms and to
+  // terminate on rational trees when occurs_check is disabled.
+  const copies = new Map([[resolved, copied]]);
+  const pending = [{ source: resolved, target: copied }];
+  while (pending.length > 0) {
+    const { source, target } = pending.pop();
+    for (let index = 0; index < source.args.length; index++) {
+      const childSource = deref(source.args[index], env);
+      let childCopy = copies.get(childSource);
+      if (childCopy == null) {
+        childCopy = makeCopy(childSource);
+        if (childSource.type !== VAR && childSource.args.length > 0) {
+          copies.set(childSource, childCopy);
+          pending.push({ source: childSource, target: childCopy });
+        }
+      }
+      target.args[index] = childCopy;
+    }
+  }
   return copied;
 }
 

package/test/run-regression.mjs

@@ -4042,6 +4042,23 @@ child.stdin.write(\`consult(${consultedAtom}).\\n\`);
         assertEqual(result.stderr, '', 'stderr');
       },
     },
+    {
+      name: 'traditional depth-first mode keeps deep non-tail continuations bounded',
+      run: () => {
+        const source = `
+countdown(0, 0) :- !.
+countdown(N, Result) :-
+    Next is N-1,
+    countdown(Next, Partial),
+    Result is Partial+1.
+answer(Result) :- countdown(2048, Result), Result = 2048.
+`;
+        const result = run(source, { goal: 'answer(Result)', autoTabling: false });
+        assertEqual(result.stdout, 'answer(2048).\n', 'deep non-tail answer');
+        assertEqual(result.stats.max_goal_count <= 70, true,
+          'caller continuations stay opaque instead of growing one goal per recursive layer');
+      },
+    },
     {
       name: '--portable rejects implementation-specific library dependencies',
       run: () => {
@@ -6126,7 +6143,9 @@ answer(ok) :-
         assertEqual(Boolean(registry.get('is', 2)), true, 'ISO is/2 exists');
         assertEqual(Boolean(registry.get('append', 3)), false, 'append/3 is not ISO core');
         assertEqual(library.eyePrologLibrary, true, 'complete registry marker');
-        assertEqual(library.defs.size, 161, 'EyeProlog registry contains ISO definitions, cleanup controls, observability extensions, WFS tnot/1, and generic library adapters');
+        assertEqual(library.defs.size, 163, 'EyeProlog registry contains ISO definitions, cleanup controls, observability extensions, WFS tnot/1, and generic library adapters');
+        assertEqual(registry.get('eyeprolog__random_value', 1), null, 'native random helper is absent from the ISO registry');
+        assertEqual(Boolean(library.get('eyeprolog__random_value', 1)), true, 'native random helper is an internal EyeProlog library adapter');
         assertEqual(Boolean(registry.get('phrase', 2)), true, 'Part 3 phrase/2 exists');
         assertEqual(Boolean(registry.get('phrase', 3)), true, 'Part 3 phrase/3 exists');
         assertEqual(registry.get('statistics', 0), null, 'statistics/0 is absent from the ISO registry');
@@ -6143,9 +6162,9 @@ answer(ok) :-
         assertEqual(Boolean(library.get('call_cleanup', 2)), true, 'call_cleanup/2 is an EyeProlog cleanup control');
         assertEqual(registry.get('setup_call_cleanup', 3), null, 'setup_call_cleanup/3 is absent from the ISO registry');
         assertEqual(Boolean(library.get('setup_call_cleanup', 3)), true, 'setup_call_cleanup/3 is an EyeProlog cleanup control');
-        assertEqual(registeredNativeEyePrologLibraryNames().length, 57, 'public host-supported EyeProlog library count');
+        assertEqual(registeredNativeEyePrologLibraryNames().length, 58, 'public host-supported EyeProlog library count');
         assertEqual(eyePrologPortableLibraryIndicators.length, 241, 'portable Prolog library count');
-        assertEqual(eyePrologInteropLibraryIndicators.length, 188, 'cross-implementation interop profile count');
+        assertEqual(eyePrologInteropLibraryIndicators.length, 189, 'cross-implementation interop profile count');
         assertEqual(eyePrologInteropLibraryModules.length, 23, 'common explicit library module profile count');
         assertEqual(eyePrologInteropAutoload['member/2'], 'lists', 'member/2 canonical autoload');
         assertEqual(eyePrologInteropAutoload['between/3'], 'between', 'between/3 canonical internal autoload');
@@ -6154,9 +6173,10 @@ answer(ok) :-
         assertEqual(eyePrologInteropAutoload['time/1'], 'iso_ext', 'time/1 canonical interop autoload');
         assertEqual(eyePrologInteropAutoload['.../2'], 'iso_ext', '.../2 canonical interop autoload');
         assertEqual(eyePrologInteropAutoload['set_nth0/4'] ?? null, null, 'EyeProlog-only set_nth0/4 is not autoloadable');
-        assertEqual(eyePrologNativeLibraryIndicators.length, 57, 'host-supported library count');
+        assertEqual(eyePrologNativeLibraryIndicators.length, 58, 'host-supported library count');
         assertEqual(eyePrologNativeLibraryIndicators.slice(0, 3).join(','), 'call_nth/2,freeze/2,dif/2', 'control and constraint predicates requiring host support');
-        assertEqual(eyePrologLibraryIndicators.length, 298, 'complete non-ISO EyeProlog library surface');
+        assertEqual(eyePrologNativeLibraryIndicators.includes('random/1'), true, 'stateful random/1 is classified as host-supported');
+        assertEqual(eyePrologLibraryIndicators.length, 299, 'complete non-ISO EyeProlog library surface');
         assertEqual(registry.get('eyeprolog__call_nth', 2), null, 'private call_nth adapter is absent from ISO registry');
         assertEqual(Boolean(library.get('eyeprolog__call_nth', 2)), true, 'private call_nth adapter is registered for EyeProlog');
         assertEqual(Boolean(library.get('eyeprolog__call_residue_vars', 2)), true, 'private call_residue_vars adapter is registered for EyeProlog');

package/the-art-of-eyeprolog.md

@@ -6237,12 +6237,12 @@ so side effects occur in Prolog execution order.
 
 ### The EyeProlog library
 
-EyeProlog exposes **298 distinct non-ISO library and normal-extension predicate
+EyeProlog exposes **299 distinct non-ISO library and normal-extension predicate
 indicators** in addition to the 129 indicators in its isolated ISO profile.
 **241 are defined entirely as ordinary Prolog clauses** in focused modules under
-`src/lib/`; **57 use host support** for control, attributed variables,
+`src/lib/`; **58 use host support** for control, attributed variables,
 constraints, or observability. The ISO and library catalogs therefore cover
-**427 distinct predicate indicators**. Normal-mode controls and observability
+**428 distinct predicate indicators**. Normal-mode controls and observability
 relations that do not belong to a library, such as `call_cleanup/2`,
 `setup_call_cleanup/3`, `statistics/0,2`, and `tnot/1`, are documented in their
 own sections rather than counted as library predicates. `time/1` is additionally
@@ -6337,7 +6337,7 @@ bindings make one aligned subterm pair sufficient. For example:
 | `library(pio)` | `phrase_from_file/2`, `phrase_from_file/3`, `phrase_to_file/2`, `phrase_to_file/3`, `phrase_to_stream/2` | Eager portable DCG file and stream I/O |
 | `library(primes)` | `smallest_divisor_from/3` | Prime factor support |
 | `library(prologue)` | `member/2`, `append/3`, `length/2`, `between/3`, `select/3`, `succ/2`, `maplist/2`, `maplist/3`, `maplist/4`, `maplist/5`, `maplist/6`, `maplist/7`, `maplist/8`, `nth0/3`, `nth0/4`, `nth1/3`, `nth1/4`, `call_nth/2`, `freeze/2`, `foldl/4`, `foldl/5`, `foldl/6`, `countall/2` | Legacy facade over canonical focused modules |
-| `library(random)` | `maybe/0`, `random/3`, `random_integer/3`, `set_random/1` | Common mutable-seed interface plus EyeProlog's pure state-threaded generator |
+| `library(random)` | `maybe/0`, `random/1`, `random/3`, `random_integer/3`, `set_random/1` | Common mutable-seed interface plus EyeProlog's pure state-threaded generator |
 | `library(reif)` | `,/3`, `;/3`, `=/3`, `cond_t/3`, `dif/3`, `if_/3`, `memberd_t/3`, `tfilter/3`, `tmember/2`, `tmember_t/3`, `tpartition/4` | Reified conditions and list filtering; reused upstream source |
 | `library(si)` | `atom_si/1`, `integer_si/1`, `atomic_si/1`, `list_si/1`, `character_si/1`, `term_si/1`, `chars_si/1`, `dif_si/2`, `not_si/1`, `when_si/2` | Sufficient-instantiation checks used by CLP(Z) |
 | `library(strings)` | `matches/3`, `split/3`, `replace/4`, `lowercase/2`, `uppercase/2`, `trim/2`, `number_string/2`, `atom_string/2`, `term_string/2`, `string_concat/3`, `contains/2`, `matches/2`, `join/3`, `substring/4` | Text relations |
@@ -6558,6 +6558,12 @@ is a compatible declaration rather than a second tabling engine.
 `format_time//2` supports the documented year, month, day, time, month-name,
 weekday-name, and day-of-year specifiers.
 
+`random/1` keeps the common mutable-seed interface but uses a private native
+state step for hot-loop performance; its public sequence remains the same
+Park-Miller sequence used by the portable explicit-state `random/3`. The helper
+is internal to the normal EyeProlog registry and is not part of the ISO or
+public library predicate catalogs.
+
 `uuidv4/1`, `uuidv4_string/1`, and `uuid_string/2` provide the common UUID byte
 list and character-list interface. `uuid(+Seed0,-UUID,-Seed)` remains an
 EyeProlog extension that creates a version 4 UUID atom using pure `random/3`.
@@ -6605,6 +6611,7 @@ before calling the corresponding predicate.
 | Predicates and principal modes | Behavior |
 | --- | --- |
 | `lt(+A,+B)`, `le(+A,+B)`, `gt(+A,+B)`, `ge(+A,+B)` | Compare integers exactly, finite numeric text numerically, `PnYnMnD` duration text component-wise, and other lexical values by string order. These differ from ISO arithmetic comparison and standard term order. |
+| `random(-Value)` | Stateful Park-Miller step using the library seed set by `set_random/1`; implemented through a private native fast path while retaining the same sequence and numeric conversion as `random/3`. |
 | `random(+Seed0,-Value,-Seed)` | Portable Park-Miller generator with explicit state. `Value` is in `[0,1)`; pass the returned integer `Seed` to the next call. The same initial integer seed always reproduces the same sequence. |
 | `difference(+End,+Start,-Duration)` | Portable Prolog. Computes a nonnegative calendar difference between ISO date atoms/character lists and returns atom `'PnYnMnD'`. Invalid dates or an end before the start fail. |