eyeprolog 1.3.72 → 1.3.74

package/package.json

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

package/src/atts.js

@@ -69,7 +69,8 @@ function* getAttsBuiltin({ goal, env }) {
   if (pattern.type === VAR) {
     if (attributes.length === 0) return;
     const next = env.clone();
-    if (unify(goal.args[1], listFromItems(attributes), next)) yield next;
+    if (unify(goal.args[1], listFromItems(attributes), next,
+      { knownNonoccurringVariables: goal._firstUseVariables })) yield next;
     return;
   }
 
@@ -89,7 +90,10 @@ function* getAttsBuiltin({ goal, env }) {
   }
   if (stored == null) return;
   const next = env.clone();
-  if (unify(inner, stored, next, { skipVariableConstraints: true })) yield next;
+  if (unify(inner, stored, next, {
+    skipVariableConstraints: true,
+    knownNonoccurringVariables: goal._firstUseVariables,
+  })) yield next;
 }
 
 function attributeName(term, env) {
@@ -117,7 +121,10 @@ function* getAttrBuiltin({ goal, env }) {
   const stored = env.getPrologAttribute(variableTerm.name, owner, name, 1);
   if (stored == null) return;
   const next = env.clone();
-  if (unify(goal.args[2], stored.args[0], next, { skipVariableConstraints: true })) yield next;
+  if (unify(goal.args[2], stored.args[0], next, {
+    skipVariableConstraints: true,
+    knownNonoccurringVariables: goal._firstUseVariables,
+  })) yield next;
 }
 
 function* delAttrBuiltin({ goal, env }) {
@@ -163,7 +170,8 @@ function* getAttrListBuiltin({ goal, env }) {
   if (entries.length === 0) return;
   const encoded = entries.map(({ module, attribute }) => compound(':', [atom(module), attribute]));
   const next = env.clone();
-  if (unify(goal.args[1], listFromItems(encoded), next)) yield next;
+  if (unify(goal.args[1], listFromItems(encoded), next,
+    { knownNonoccurringVariables: goal._firstUseVariables })) yield next;
 }
 
 function* getFromAttrListBuiltin({ goal, env }) {
@@ -179,7 +187,10 @@ function* getFromAttrListBuiltin({ goal, env }) {
   const stored = env.getPrologAttribute(variableTerm.name, moduleTerm.name, signature.name, signature.arity);
   if (stored == null) return;
   const next = env.clone();
-  if (unify(pattern, stored, next, { skipVariableConstraints: true })) yield next;
+  if (unify(pattern, stored, next, {
+    skipVariableConstraints: true,
+    knownNonoccurringVariables: goal._firstUseVariables,
+  })) yield next;
 }
 
 function* putToAttrListBuiltin({ goal, env }) {

package/src/lib/clpz.pl

@@ -2248,10 +2248,15 @@ all_different([X|Right], Left, Orig) -->
 all_distinct(Ls) :-
         fd_must_be_list(Ls, all_distinct(Ls)-1),
         maplist(fd_variable, Ls),
-        make_propagator(pdistinct(Ls), Prop),
-        new_queue(Q0),
-        phrase((distinct_attach(Ls, Prop, []),trigger_prop(Prop),do_queue), [Q0], _),
-        variables_same_queue(Ls).
+        % A ground list needs validation, but no attributed propagator.
+        (   ground(Ls) ->
+            sort(Ls, Distinct),
+            same_length(Ls, Distinct)
+        ;   make_propagator(pdistinct(Ls), Prop),
+            new_queue(Q0),
+            phrase((distinct_attach(Ls, Prop, []),trigger_prop(Prop),do_queue), [Q0], _),
+            variables_same_queue(Ls)
+        ).
 
 %% nvalue(?N, +Vars).
 %
@@ -6707,10 +6712,21 @@ serialize_upper_bound(I, D_I, J, D_J, MState) -->
 
 element(N, Is, V) :-
         must_be(list, Is),
-        length(Is, L),
-        N in 1..L,
-        element_(Is, 1, N, V),
-        propagator_init_trigger([N|Is], pelement(N,Is,V)).
+        % A constant table is one extensional relation; expanding it into
+        % reified implications and a second propagator is needlessly costly.
+        (   maplist(integer, Is) ->
+            element_relation(Is, 1, Relation),
+            tuples_in([[N,V]], Relation)
+        ;   length(Is, L),
+            N in 1..L,
+            element_(Is, 1, N, V),
+            propagator_init_trigger([N|Is], pelement(N,Is,V))
+        ).
+
+element_relation([], _, []).
+element_relation([V|Vs], N, [[N,V]|Relation]) :-
+        N1 is N + 1,
+        element_relation(Vs, N1, Relation).
 
 element_domain(V, VD) :-
         (   fd_get(V, VD, _) -> true
@@ -6799,8 +6815,15 @@ global_cardinality(Xs, Pairs, Options) :-
         ).
 
 keys_costs(Keys, X, Row, C) :-
-        element(N, Keys, X),
-        element(N, Row, C).
+        % Keys and matrix rows are integers here. Zip them once instead of
+        % connecting two element/3 constraints through an auxiliary index.
+        keys_cost_relation(Keys, Row, Relation),
+        tuples_in([[X,C]], Relation).
+
+keys_cost_relation([Key|Keys], [Cost|Costs], [[Key,Cost]|Relation]) :-
+        keys_cost_relation(Keys, Costs, Relation).
+keys_cost_relation([], _, []).
+keys_cost_relation([_|_], [], []).
 
 gcc_pair(Pair) :-
         (   Pair = Key-Val ->

package/src/program.js

@@ -34,6 +34,28 @@ import {
 const DEFER_PROGRAM_BUILD = Symbol('deferProgramBuild');
 const FAST_PARSE_ABORT = Symbol('fastParseAbort');
 const PROGRAM_BUILD_BATCH_SIZE = 16384;
+const preparedBundledLibraryCache = new Map();
+
+function preparedBundledLibraryCacheKey(program, options) {
+  const filename = String(options.filename ?? '');
+  if (filename !== standardLibrarySources.get('clpz')?.filename) return null;
+  // A user hook deliberately defined before use_module/1 is allowed to
+  // transform bundled source. Such a program needs its own ordinary expansion.
+  if (program.groups.has(modulePredicateKey('user', 'term_expansion', 2)) ||
+      program.groups.has(modulePredicateKey('user', 'goal_expansion', 2))) return null;
+  return `${filename}\u0000${options.sourceMetadata === false ? 'compact' : 'metadata'}`;
+}
+
+function cachedClauseCopy(clause) {
+  const copy = { ...clause };
+  if (Array.isArray(clause.body)) copy.body = [...clause.body];
+  if (clause.source != null) copy.source = { ...clause.source };
+  delete copy.index;
+  delete copy.groundHead;
+  delete copy.scalarHead;
+  delete copy._localFreshPlan;
+  return copy;
+}
 
 function termContainsStringExtension(term, seen = new Set()) {
   if (term == null || typeof term !== 'object' || seen.has(term)) return false;
@@ -1074,6 +1096,8 @@ function sourcePath(options) {
 function loadSourceIntoBuilder(builder, source, options, ensured, loadedModules, fast, context) {
   const batch = [];
   const deferredGoalExpansions = [];
+  const preparedCacheKey = preparedBundledLibraryCacheKey(builder.program, options);
+  const preparedForCache = preparedCacheKey == null ? null : [];
   const flush = () => {
     if (batch.length === 0) return;
     builder.addClauses(batch);
@@ -1106,41 +1130,12 @@ function loadSourceIntoBuilder(builder, source, options, ensured, loadedModules,
     processPreparedClause(clause);
   };
 
-  const processPreparedClause = (inputClause) => {
-    let clause = inputClause;
-    const lexicalModule = context.module;
-
-    // Grammar-rule expansion belongs to ISO/IEC TS 13211-3 rather than the
-    // Part 1 strict-core language.  In strict core mode -->/2 remains the
-    // ordinary predefined operator term from Table 7 and is not rewritten.
-    const grammarClause = builder.program.strictIso ? null : expandDcgRuleClause(clause, lexicalModule);
-    if (grammarClause) clause = grammarClause;
-
-    // A source module qualifier on a clause head selects the procedure owner,
-    // while unqualified calls in the body retain the lexical module of the
-    // source text. This distinction is essential for conventional hooks such
-    // as user:term_expansion/2 defined from library modules.
-    clause = normalizeQualifiedClauseHead(clause, lexicalModule);
-
-    if (!builder.program.strictIso && !isDirectiveClause(clause)) {
-      try {
-        expandClauseGoals(builder.program, clause, lexicalModule, {
-          module: lexicalModule,
-          filename: options.filename ?? '<input>',
-        });
-      } catch (error) {
-        // Scryer-compatible goal-expansion hooks may refer to helper predicates
-        // that occur later in the same source file. Keep loading so those
-        // helpers become visible, then retry this clause at end-of-source.
-        // A still-missing helper (or any other expansion error) is reported on
-        // the final retry rather than being silently ignored.
-        if (!(error instanceof PrologError) || error.formal !== 'existence_error(procedure)') throw error;
-        clause.module ??= lexicalModule;
-        clause.textUnit ??= context.textUnit;
-        deferredGoalExpansions.push({ clause, lexicalModule });
-        return;
+  const acceptPreparedClause = (clause, lexicalModule, record = true) => {
+    const remember = () => {
+      if (record && preparedForCache != null) {
+        preparedForCache.push({ clause: cachedClauseCopy(clause), lexicalModule });
       }
-    }
+    };
 
     const moduleDeclaration = moduleDirective(clause);
     if (moduleDeclaration) {
@@ -1148,6 +1143,7 @@ function loadSourceIntoBuilder(builder, source, options, ensured, loadedModules,
       clause.module = moduleDeclaration.name;
       clause.textUnit = context.textUnit;
       clause.moduleFilename = options.filename ?? '<input>';
+      remember();
       builder.addClauses([clause]);
       context.module = moduleDeclaration.name;
       loadedModules.add(moduleDeclaration.name);
@@ -1158,6 +1154,7 @@ function loadSourceIntoBuilder(builder, source, options, ensured, loadedModules,
       flush();
       clause.module = context.module;
       clause.textUnit = context.textUnit;
+      remember();
       builder.addClauses([clause]);
       const libraryName = libraryDesignationName(use.designation);
       if (libraryName != null) {
@@ -1185,6 +1182,7 @@ function loadSourceIntoBuilder(builder, source, options, ensured, loadedModules,
         const bodyModule = clause.lexicalModule ?? lexicalModule;
         for (const goal of clause.body) annotateGoalModule(goal, bodyModule);
       }
+      remember();
       const isExpansionHook = !isDirectiveClause(clause) &&
         clause.head?.arity === 2 && ['term_expansion', 'goal_expansion'].includes(clause.head?.name);
       if (isExpansionHook) {
@@ -1199,6 +1197,7 @@ function loadSourceIntoBuilder(builder, source, options, ensured, loadedModules,
       return;
     }
     flush();
+    remember();
     if (builder.program.strictIso && include.name === 'ensure_loaded') {
       builder.lastPredicateByText.set(context.textUnit ?? '<input>', '@directive');
     }
@@ -1212,6 +1211,54 @@ function loadSourceIntoBuilder(builder, source, options, ensured, loadedModules,
     }
   };
 
+  const processPreparedClause = (inputClause) => {
+    let clause = inputClause;
+    const lexicalModule = context.module;
+
+    // Grammar-rule expansion belongs to ISO/IEC TS 13211-3 rather than the
+    // Part 1 strict-core language.  In strict core mode -->/2 remains the
+    // ordinary predefined operator term from Table 7 and is not rewritten.
+    const grammarClause = builder.program.strictIso ? null : expandDcgRuleClause(clause, lexicalModule);
+    if (grammarClause) clause = grammarClause;
+
+    // A source module qualifier on a clause head selects the procedure owner,
+    // while unqualified calls in the body retain the lexical module of the
+    // source text. This distinction is essential for conventional hooks such
+    // as user:term_expansion/2 defined from library modules.
+    clause = normalizeQualifiedClauseHead(clause, lexicalModule);
+
+    if (!builder.program.strictIso && !isDirectiveClause(clause)) {
+      try {
+        expandClauseGoals(builder.program, clause, lexicalModule, {
+          module: lexicalModule,
+          filename: options.filename ?? '<input>',
+        });
+      } catch (error) {
+        // Scryer-compatible goal-expansion hooks may refer to helper predicates
+        // that occur later in the same source file. Keep loading so those
+        // helpers become visible, then retry this clause at end-of-source.
+        // A still-missing helper (or any other expansion error) is reported on
+        // the final retry rather than being silently ignored.
+        if (!(error instanceof PrologError) || error.formal !== 'existence_error(procedure)') throw error;
+        clause.module ??= lexicalModule;
+        clause.textUnit ??= context.textUnit;
+        deferredGoalExpansions.push({ clause, lexicalModule });
+        return;
+      }
+    }
+
+    acceptPreparedClause(clause, lexicalModule);
+  };
+
+  const cachedEntry = preparedCacheKey == null ? null : preparedBundledLibraryCache.get(preparedCacheKey);
+  if (cachedEntry?.source === source) {
+    for (const item of cachedEntry.clauses) {
+      acceptPreparedClause(cachedClauseCopy(item.clause), item.lexicalModule, false);
+    }
+    flush();
+    return true;
+  }
+
   if (fast) {
     const acceptBinary = (headName, head0Type, head0Name, head1Type, head1Name,
         bodyName, body0Type, body0Name, body1Type, body1Name) => {
@@ -1235,9 +1282,12 @@ function loadSourceIntoBuilder(builder, source, options, ensured, loadedModules,
         module: lexicalModule,
         filename: options.filename ?? '<input>',
       });
-      for (const goal of clause.body) annotateGoalModule(goal, clause.lexicalModule ?? lexicalModule);
-      builder.addClauses([clause]);
+      acceptPreparedClause(clause, lexicalModule);
     }
+    flush();
+  }
+  if (preparedCacheKey != null) {
+    preparedBundledLibraryCache.set(preparedCacheKey, { source, clauses: preparedForCache });
   }
   return true;
 }

package/src/solver.js

@@ -1269,22 +1269,80 @@ function clauseLocalFreshPlan(clause) {
 
 function freshVariableSet(names, freshVariables) {
   if (names.length === 0) return null;
-  const fresh = new Set();
+  const fresh = [];
   for (const name of names) {
     const term = freshVariables.get(name);
-    if (term != null) fresh.add(term.name);
+    if (term != null) fresh.push(term.name);
   }
-  return fresh.size === 0 ? null : fresh;
+  if (fresh.length === 0) return null;
+  // Most clauses introduce only one or two first-use variables. A tiny linear
+  // membership object avoids allocating and populating an OrderedHashSet on
+  // every invocation; use the native Set once linear lookup would lose.
+  return fresh.length <= 4 ? new SmallFreshVariableSet(fresh) : new Set(fresh);
+}
+
+class SmallFreshVariableSet {
+  constructor(values) {
+    this.values = values;
+  }
+
+  has(value) {
+    for (let index = 0; index < this.values.length; index++) {
+      if (this.values[index] === value) return true;
+    }
+    return false;
+  }
+}
+
+function goalUsesFirstUseProof(term) {
+  if (term?.type !== COMPOUND) return false;
+  if ((term.name === '=' && term.arity === 2)
+    || (term.name === 'get_atts' && term.arity === 2)
+    || (term.name === 'get_attr' && term.arity === 3)
+    || (term.name === '$get_attr_list' && term.arity === 2)
+    || (term.name === '$get_from_attr_list' && term.arity === 3)) return true;
+  if ((term.name === ',' || term.name === ';' || term.name === '->') && term.arity === 2) {
+    return goalUsesFirstUseProof(term.args[0]) || goalUsesFirstUseProof(term.args[1]);
+  }
+  if (term.name === '\\+' && term.arity === 1) return goalUsesFirstUseProof(term.args[0]);
+  if (term.name === ':' && term.arity === 2) return goalUsesFirstUseProof(term.args[1]);
+  return false;
 }
 
 function attachBodyLocalFreshVariables(freshBody, plan, freshVariables) {
+  const attach = (term, knownNonoccurringVariables) => {
+    if (term?.type !== COMPOUND) return;
+    if (term.name === '=' && term.arity === 2) {
+      term._knownNonoccurringVariables = knownNonoccurringVariables;
+    } else if ((term.name === 'get_atts' && term.arity === 2)
+      || (term.name === 'get_attr' && term.arity === 3)
+      || (term.name === '$get_attr_list' && term.arity === 2)
+      || (term.name === '$get_from_attr_list' && term.arity === 3)) {
+      term._firstUseVariables = knownNonoccurringVariables;
+    }
+    // Goal expansion commonly wraps a primitive in a conjunction or
+    // if-then-else. Preserve the proof on the executable child; attaching it
+    // only to the outer control term leaves get_atts/2 unable to use it.
+    if ((term.name === ',' || term.name === ';' || term.name === '->') && term.arity === 2) {
+      attach(term.args[0], knownNonoccurringVariables);
+      attach(term.args[1], knownNonoccurringVariables);
+    } else if (term.name === '\\+' && term.arity === 1) {
+      attach(term.args[0], knownNonoccurringVariables);
+    } else if (term.name === ':' && term.arity === 2) {
+      attach(term.args[1], knownNonoccurringVariables);
+    }
+  };
   for (let index = 0; index < freshBody.length; index++) {
     const goal = freshBody[index];
+    if (!goalUsesFirstUseProof(goal)) continue;
     const knownNonoccurringVariables = freshVariableSet(plan[index] ?? [], freshVariables);
     if (knownNonoccurringVariables == null || goal?.type !== COMPOUND) continue;
-    if (goal.name === '=' && goal.arity === 2) {
-      goal._knownNonoccurringVariables = knownNonoccurringVariables;
-    }
+    // Host builtins that only unify an output with already-existing logical
+    // data can use the same first-use proof without treating the variable as a
+    // WAM-style local across the whole call. This is especially important for
+    // get_atts/2: CLP(Z) attributes are large trees that would otherwise be
+    // traversed once per freshly introduced pattern variable.
+    attach(goal, knownNonoccurringVariables);
   }
 }
 
@@ -2376,10 +2434,14 @@ function tryPushGroundScalarRuleFrame(stack, solver, group, goal, rest, env, dep
   // A fully-ground call to a single flat rule can be checked without freshening
   // the rule or allocating an Env for every body literal.  This is especially
   // valuable for data-validation joins such as rb(A,B,C,D,E) in ORB Join2.
-  if (!termIsGround(goal, env) || group.clauses.length !== 1) return false;
+  // Reject ineligible rule shapes before recursively resolving the goal. Most
+  // library predicates have several clauses, and CLP(Z) calls are commonly
+  // large non-ground structures for which that groundness walk is pure cost.
+  if (group.clauses.length !== 1) return false;
   const clause = group.clauses[0];
   if (clause?.compactBinary === true || clause.body.length < 2 || clause.head.type !== COMPOUND) return false;
   if (clause.head.name !== goal.name || clause.head.arity !== goal.arity) return false;
+  if (!termIsGround(goal, env)) return false;
 
   const bindings = new Map();
   const resolvedGoal = copyResolved(goal, env);
@@ -2438,14 +2500,17 @@ function tryPushGroundChainFrames(stack, solver, group, goal, rest, env, depth,
   // This is a search-control optimization only. It fires only while each step
   // has exactly one matching clause and a single ground body goal; otherwise the
   // normal clause path below remains authoritative.
-  if (!termIsGround(goal, env)) return false;
   // The chain matcher below only propagates variables bound to flat scalar
   // head arguments (or literal scalars). Keep this optimization on that flat
-  // domain instead of recursively copying an arbitrary ground compound just
-  // to discover later that a rule shape is unsupported. Deep list arguments
-  // such as DCG state therefore fall straight through to normal resolution.
-  const resolvedArgs = goal.args.map((arg) => derefForLocal(arg, env));
-  if (!resolvedArgs.every(isScalarTerm)) return false;
+  // domain. Resolving the top-level arguments first proves groundness when all
+  // of them are scalars and avoids recursively walking arbitrary CLP(Z) terms
+  // only to reject them immediately afterward.
+  const resolvedArgs = new Array(goal.arity);
+  for (let index = 0; index < goal.arity; index++) {
+    const resolved = derefForLocal(goal.args[index], env);
+    if (!isScalarTerm(resolved)) return false;
+    resolvedArgs[index] = resolved;
+  }
 
   const baseEnv = env;
   let currentGroup = group;

package/src/term.js

@@ -8,7 +8,17 @@ export const STRING = 'string';
 export const NUMBER = 'number';
 export const COMPOUND = 'compound';
 const EMPTY_ARGS = Object.freeze([]);
-const ENV_FLATTEN_DEPTH = 1024;
+// Deep persistent binding chains make the many negative variable lookups in
+// constraint propagation linear in the complete history. Periodically fold
+// 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 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
+// variable names; binding reachability is still checked against each Env.
+const structuralVariableCache = new WeakMap();
 
 export class Term {
   constructor(type, name, args = []) {
@@ -227,7 +237,10 @@ export class Env {
     return undefined;
   }
   bind(name, term) {
-    if (this._state.depth >= ENV_FLATTEN_DEPTH) {
+    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)) {
@@ -531,7 +544,35 @@ export function isConjunction(term) {
   return term?.type === COMPOUND && term.name === ',' && term.arity === 2;
 }
 
-function occurs(variableName, term, env) {
+function structuralVariableNames(term) {
+  if (isScalar(term)) return EMPTY_ARGS;
+  if (term?.type === VAR) return [term.name];
+  if (term?.type !== COMPOUND) return EMPTY_ARGS;
+
+  const cached = structuralVariableCache.get(term);
+  if (cached !== undefined) return cached;
+
+  const names = new Set();
+  const stack = [term];
+  const seenTerms = new Set();
+  while (stack.length) {
+    const current = stack.pop();
+    if (current?.type === VAR) {
+      names.add(current.name);
+      continue;
+    }
+    if (isCompactList(current)) return null;
+    if (current?.type !== COMPOUND || seenTerms.has(current)) continue;
+    seenTerms.add(current);
+    for (let i = 0; i < current.arity; i++) stack.push(current.args[i]);
+  }
+
+  const result = names.size === 0 ? EMPTY_ARGS : [...names];
+  structuralVariableCache.set(term, result);
+  return result;
+}
+
+function occursUncached(variableName, term, env) {
   // Walk bindings and compound arguments iteratively so the occurs check also
   // remains safe for very deep terms. The visited sets make this defensive
   // against cycles introduced through the public Env API.
@@ -559,6 +600,50 @@ function occurs(variableName, term, env) {
   return false;
 }
 
+function occurs(variableName, term, env) {
+  if (isScalar(term)) return false;
+  const initial = structuralVariableNames(term);
+  if (initial == null) return occursUncached(variableName, term, env);
+  if (initial.length === 0) return false;
+
+  // Lists, wrappers, and arithmetic expressions commonly contain one logical
+  // variable. Follow that unary binding chain without allocating a work queue
+  // and hash set for every occurs check. Fall back to the general graph walk
+  // as soon as a binding fans out.
+  if (initial.length === 1) {
+    let name = initial[0];
+    const seen = [];
+    while (true) {
+      if (name === variableName) return true;
+      for (let index = 0; index < seen.length; index++) {
+        if (seen[index] === name) return false;
+      }
+      seen.push(name);
+      const binding = env?.get(name);
+      if (binding === undefined) return false;
+      const names = structuralVariableNames(binding);
+      if (names == null || names.length > 1) return occursUncached(variableName, term, env);
+      if (names.length === 0) return false;
+      name = names[0];
+    }
+  }
+
+  const pending = initial.slice();
+  const seenVariables = new Set();
+  for (let index = 0; index < pending.length; index++) {
+    const name = pending[index];
+    if (name === variableName) return true;
+    if (seenVariables.has(name)) continue;
+    seenVariables.add(name);
+    const binding = env?.get(name);
+    if (binding === undefined) continue;
+    const names = structuralVariableNames(binding);
+    if (names == null) return occursUncached(variableName, term, env);
+    for (const child of names) pending.push(child);
+  }
+  return false;
+}
+
 export function unify(left, right, env, options = {}) {
   // Iterative unification avoids deep JavaScript recursion on long lists or
   // deeply nested compounds. The occurs check gives EyeProlog finite-tree
@@ -686,9 +771,16 @@ export function freshTerm(term, suffix, variables = new Map()) {
     }
     return fresh;
   }
-  const fresh = term.type === COMPOUND && term.arity === 0
-    ? atom(term.name)
-    : new Term(term.type, term.name, term.args.map((arg) => freshTerm(arg, suffix, variables)));
+  let fresh;
+  if (term.type === COMPOUND && term.arity === 0) {
+    fresh = atom(term.name);
+  } else {
+    const args = new Array(term.args.length);
+    for (let index = 0; index < args.length; index++) {
+      args[index] = freshTerm(term.args[index], suffix, variables);
+    }
+    fresh = new Term(term.type, term.name, args);
+  }
   if (term.module != null) fresh.module = term.module;
   return fresh;
 }