eyeprolog 1.3.12 → 1.3.14

package/README.md

@@ -107,13 +107,14 @@ keeps both long-running filters such as `\+ phrase((..., Pattern), Sequence)`
 and repeated same-input probes bounded without turning memory safety into a
 per-call cache-eviction cost.
 
-Finite-tree unification also recognizes a conservative first-use case inspired
-by the local-variable optimization used by WAM-family systems. In a freshly
-renamed clause, a singleton head variable or a variable that first appears once
-in a direct `=/2` goal cannot already occur in the value it is about to receive,
-so that one binding can skip an otherwise redundant occurs traversal. Repeated
+Finite-tree unification also accepts an internal proven-nonoccurrence hint: when
+the solver can prove that a variable cannot occur in the value it is about to
+receive, that binding skips an otherwise redundant occurs traversal. The main
+source-level case is conservative first use in a freshly renamed clause, inspired
+by the local-variable optimization used by WAM-family systems; native construction
+paths such as relational `length/2` reuse the same unifier mechanism. Repeated
 variables, variables seen earlier in the clause, and ordinary public unification
-remain fully occurs-checked. This is a source-level proof, not a WAM-style
+remain fully occurs-checked. This is a proof local to one binding, not a WAM-style
 local/global variable stack. `phrase/2` likewise supplies its fixed `[]`
 remainder directly to the grammar; `phrase/3` retains its delayed final output
 unification for steadfastness.
@@ -200,8 +201,8 @@ noun --> [world] | [prolog].
 %% goal: phrase(sentence, Words)
 ```
 
-EyeProlog also adds 126 public library predicate indicators to its 129-entry ISO
-profile. **87 are implemented entirely as ordinary Prolog clauses** in focused
+EyeProlog also adds 128 public library predicate indicators to its 129-entry ISO
+profile. **88 are implemented entirely as ordinary Prolog clauses** in focused
 modules under `src/lib/`; the remaining control predicates and finite-domain
 `library(clpz)` kernel use backtrackable host support.
 They are ISO/IEC 13211-2 modules loaded explicitly by purpose, such as
@@ -224,8 +225,13 @@ headroom, so an exhausted finite heap is reported as a catchable
 `resource_error(memory)` instead of degenerating into quadratic list checks.
 
 `library(iso_ext)` is also accepted as a common interop module name.
-EyeProlog exports `call_nth/2` there, so Scryer-style source can explicitly use
-`:- use_module(library(iso_ext)).`; unqualified source may still autoload it.
+EyeProlog exports `call_nth/2`, `time/1`, and the DCG helper `...//0` there.
+The latter describes an arbitrary number of input elements and supports the
+nonterminal hand-off benchmark discussed in issue #49. These common predicates
+may be imported explicitly, while source/CLI/API dependency loading can resolve
+their unqualified forms conservatively. For Trealla-style interactive timing,
+`time/1` is also available directly in the normal EyeProlog runtime; strict ISO
+mode does not expose it.
 The aligned `library(lists)` and `library(iso_ext)` exports are kept disjoint so
 they can be imported together without an accidental import conflict. EyeProlog's
 legacy `library(prologue)` remains a compatibility umbrella and should be

package/package.json

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

package/src/dcg.js

@@ -2,7 +2,7 @@
 // Grammar rules are lowered to ordinary clauses during program preparation;
 // phrase/2-3 use the same body expansion for dynamically supplied grammars.
 import {
-  ATOM, COMPOUND, VAR, Env, atom, compound, deref, emptyList,
+  ATOM, COMPOUND, VAR, Env, atom, compactListLength, compound, deref, emptyList,
   flattenConjunction, variable,
 } from './term.js';
 import { PrologError } from './iso.js';
@@ -280,6 +280,11 @@ export function expandDcgRuleClause(clause, defaultModule = 'user') {
 export function isListOrPartialList(term, env) {
   const seen = new Set();
   let cursor = deref(term, env);
+  // A compact list skeleton has a fixed proper spine by construction. Its
+  // elements may later receive bindings, but those bindings cannot change the
+  // list tail shape, so phrase/2-3 need not expand the entire lazy spine merely
+  // to validate it as a list.
+  if (compactListLength(cursor) != null) return true;
   while (cursor.type === COMPOUND && cursor.name === '.' && cursor.arity === 2) {
     if (seen.has(cursor)) return false;
     seen.add(cursor);

package/src/iso.js

@@ -176,13 +176,15 @@ export const eyePrologLibraryBuiltins = {
     registry.add('eyeprolog__call_nth', 2, callNthBuiltin, { eyePrologLibrary: true });
     registry.add('eyeprolog__countall', 2, countAllBuiltin, { eyePrologLibrary: true });
     registry.add('eyeprolog__freeze', 2, freezeBuiltin, { eyePrologLibrary: true });
+    registry.add('time', 1, timeBuiltin, { eyePrologLibrary: true });
+    registry.add('eyeprolog__time', 1, timeBuiltin, { eyePrologLibrary: true });
   },
 };
 
 function* unification({ goal, env }) {
   const next = env.clone();
-  const localFreshVariables = goal._localFreshVariables ?? null;
-  if (unify(goal.args[0], goal.args[1], next, { localFreshVariables })) yield next;
+  const knownNonoccurringVariables = goal._knownNonoccurringVariables ?? null;
+  if (unify(goal.args[0], goal.args[1], next, { knownNonoccurringVariables })) yield next;
 }
 function* unificationWithOccursCheck({ goal, env }) {
   const next = env.clone();
@@ -1899,29 +1901,31 @@ const bagofBuiltin = allSolutionsBuiltin(false);
 const setofBuiltin = allSolutionsBuiltin(true);
 
 function callable(term, env) {
-  term = resolveCallable(term, env);
+  term = deref(term, env);
   if (term.type === VAR) throw new PrologError('instantiation_error');
   if (term.type !== ATOM && term.type !== COMPOUND) throw new PrologError('type_error(callable)', term);
-  validateControlCallable(term, term);
+  validateControlCallable(term, term, env);
   return term;
 }
-function validateControlCallable(term, culprit) {
-  if (term.type !== COMPOUND || ![',', ';', '->'].includes(term.name) || term.arity !== 2) return;
-  for (const argument of term.args) {
-    if (argument.type === VAR) throw new PrologError('instantiation_error');
-    if (argument.type !== ATOM && argument.type !== COMPOUND) {
-      throw new PrologError('type_error(callable)', culprit);
+function validateControlCallable(term, culprit, env) {
+  // Only control constructs need their nested goals validated at meta-call
+  // entry. Walk them iteratively and dereference each nested goal lazily so
+  // passing a callable that contains a very deep data term (for example
+  // phrase(a, List) with an 8k-cell List) never consumes the JavaScript stack.
+  const pending = [term];
+  while (pending.length > 0) {
+    const current = deref(pending.pop(), env);
+    if (current.type !== COMPOUND || ![',', ';', '->'].includes(current.name) || current.arity !== 2) continue;
+    for (let index = current.arity - 1; index >= 0; index--) {
+      const argument = deref(current.args[index], env);
+      if (argument.type === VAR) throw new PrologError('instantiation_error');
+      if (argument.type !== ATOM && argument.type !== COMPOUND) {
+        throw new PrologError('type_error(callable)', culprit);
+      }
+      pending.push(argument);
     }
-    validateControlCallable(argument, culprit);
   }
 }
-function resolveCallable(term, env) {
-  const resolved = deref(term, env);
-  if (resolved.type !== COMPOUND) return resolved;
-  const callable = compound(resolved.name, resolved.args.map((arg) => resolveCallable(arg, env)));
-  if (resolved.module != null) callable.module = resolved.module;
-  return callable;
-}
 function* callBuiltin({ solver, goal, env }) {
   const child = solver.cloneForInnerGoal();
   try {
@@ -1972,6 +1976,44 @@ function* countAllBuiltin({ solver, goal, env }) {
   if (unify(goal.args[1], numberTerm(count), next)) yield next;
 }
 
+function monotonicMilliseconds() {
+  return globalThis.performance?.now?.() ?? Date.now();
+}
+
+function writeElapsedTime(solver, startedAt, inferences) {
+  const stream = solver.io.resolve(solver.io.currentOutput);
+  if (stream?.type !== 'text') throw new PrologError('permission_error(output, binary_stream)');
+  const elapsedSeconds = Math.max(0, monotonicMilliseconds() - startedAt) / 1000;
+  const mlips = elapsedSeconds > 0 ? inferences / elapsedSeconds / 1_000_000 : 0;
+  solver.io.writeUnit(
+    stream,
+    `% Time elapsed ${elapsedSeconds.toFixed(3)}s, ${inferences} Inferences, ${mlips.toFixed(3)} MLips\n`,
+  );
+}
+
+function* timeBuiltin({ solver, goal, env }) {
+  const invoked = callable(goal.args[0], env);
+  const child = solver.cloneForInnerGoal();
+  let startedAt = monotonicMilliseconds();
+  let startedInferences = child.inferenceObservation.value;
+  let yieldedAny = false;
+  try {
+    for (const answerEnv of child.solve([invoked], env, 0)) {
+      writeElapsedTime(solver, startedAt, child.inferenceObservation.value - startedInferences);
+      yieldedAny = true;
+      yield answerEnv;
+      // A resumed time/1 measures only the work required to reach the next
+      // answer, so nondeterministic calls get one timing line per solution.
+      startedAt = monotonicMilliseconds();
+      startedInferences = child.inferenceObservation.value;
+    }
+    // A call that fails without producing an answer still reports the work.
+    if (!yieldedAny) writeElapsedTime(solver, startedAt, child.inferenceObservation.value - startedInferences);
+  } finally {
+    solver.absorbStatsFrom(child);
+  }
+}
+
 function* callNthBuiltin({ solver, goal, env }) {
   const requestedTerm = deref(goal.args[1], env);
   // Zero is the one Nth value that fails before Goal is inspected.

package/src/lib/iso_ext.pl

@@ -7,17 +7,21 @@
     succ/2,
     cfor/3,
     findall/4,
-    variant/2
+    variant/2,
+    time/1,
+    '...'/2
 ]).
 
 :- meta_predicate(call_nth(0, '?')).
 :- meta_predicate(countall(0, '?')).
 :- meta_predicate(forall(0, 0)).
 :- meta_predicate(findall('?', 0, '?', '?')).
+:- meta_predicate(time(0)).
 
 % The organization and predicate contracts follow library(iso_ext) in
-% Trealla. These definitions use only EyeProlog's ISO profile; extensions that
-% require runtime cleanup, choice-point, alarm, or timeout hooks are omitted.
+% Trealla. Most definitions use only EyeProlog's ISO profile. time/1 is the
+% deliberate exception: its private adapter supplies monotonic host timing and
+% writes the measurement while the public wrapper keeps normal meta semantics.
 
 call_nth(Goal, Nth) :- eyeprolog__call_nth(Goal, Nth).
 
@@ -59,6 +63,16 @@ variant(X, Y) :-
     subsumes_term(CopyX, CopyY),
     subsumes_term(CopyY, CopyX).
 
+% Trealla-compatible timing wrapper. The private adapter measures the callable
+% while this Prolog wrapper supplies normal module/meta-predicate semantics.
+time(Goal) :- eyeprolog__time(Goal).
+
+% Trealla/Scryer DCG helper: describes an arbitrary number of elements.
+% EyeProlog's two-clause form has the same finite-input relation without the
+% Trealla-specific empty-input cut guard, so recursive calls stay cut-free.
+'...' --> [].
+'...' --> [_], '...' .
+
 iso_ext__call_all([]).
 iso_ext__call_all([Goal|Goals]) :-
     call(Goal),

package/src/repl.js

@@ -526,6 +526,7 @@ async function readSource(designation) {
 async function solveQuery(engine, state, goal, reader, output) {
   const variables = queryVariables(goal);
   const solver = state.solver;
+  const demandDriven = containsTimedGoal(goal);
   solver.solutionsSeen = 0;
   const solutions = solver.solve([goal], new engine.Env(), 0);
   let current = pullSolution(solver, solutions, reader);
@@ -544,11 +545,12 @@ async function solveQuery(engine, state, goal, reader, output) {
   let firstAnswer = true;
   let formattingAfterAdvance = false;
   while (!current.result.done) {
-    const next = pullSolution(solver, solutions, reader);
-    // The control prompt has no trailing space while it waits for input. The
-    // first space appears as soon as the user requests another solution and
-    // remains visible while pullSolution() computes; the second appears only
-    // when the requested leaf answer is ready to format.
+    // Ordinary queries keep the existing eager look-ahead so deterministic
+    // answers can end with a full stop without showing an unnecessary answer
+    // prompt. `time/1` is different: running a future solution changes what is
+    // being measured and can retain a very large current substitution. Timed
+    // queries therefore advance only after the user asks for another answer.
+    const next = demandDriven ? null : pullSolution(solver, solutions, reader);
     if (formattingAfterAdvance) output.write(' ');
     formattingAfterAdvance = false;
     output.write(current.output);
@@ -556,10 +558,8 @@ async function solveQuery(engine, state, goal, reader, output) {
     output.write(`${firstAnswer ? ' ' : ''}${answer}`);
     answersShown++;
     firstAnswer = false;
-    if (!next.error && next.result.done) {
-      // A terminal full stop cannot immediately follow a graphic token: the
-      // scanner would absorb it into that token. Insert layout so the printed
-      // answer remains valid Prolog text (issue #44).
+
+    if (demandDriven ? !solver.hasPendingAlternatives() : (!next.error && next.result.done)) {
       output.write(`${continuesGraphicToken(answer, answer.length) ? ' ' : ''}.\n`);
       return null;
     }
@@ -584,9 +584,6 @@ async function solveQuery(engine, state, goal, reader, output) {
           break;
         }
         if (control === 'f') {
-          // `f` groups leaf answers in blocks of five, rather than merely
-          // adding five more answers after whatever the user has already
-          // inspected. Stop for control again at the next 5-answer boundary.
           const remainder = answersShown % 5;
           const answersToBoundary = remainder === 0 ? 5 : 5 - remainder;
           automatic = answersToBoundary - 1;
@@ -606,6 +603,29 @@ async function solveQuery(engine, state, goal, reader, output) {
       formattingAfterAdvance = true;
     }
 
+    if (demandDriven) {
+      // The displayed timed answer is no longer needed. Drop it before
+      // resuming search so a large list substitution does not remain live only
+      // because the top level is looking for its successor.
+      current = null;
+      const requested = pullSolution(solver, solutions, reader);
+      if (requested.error) {
+        if (formattingAfterAdvance) output.write(' ');
+        formattingAfterAdvance = false;
+        output.write(requested.output);
+        if (requested.error?.name === 'HaltSignal') return { halted: true, code: requested.error.code };
+        throw requested.error;
+      }
+      if (requested.result.done) {
+        if (formattingAfterAdvance) output.write(' ');
+        formattingAfterAdvance = false;
+        output.write(`${requested.output}false.\n`);
+        return null;
+      }
+      current = requested;
+      continue;
+    }
+
     if (next.error) {
       if (formattingAfterAdvance) output.write(' ');
       formattingAfterAdvance = false;
@@ -618,6 +638,17 @@ async function solveQuery(engine, state, goal, reader, output) {
   return null;
 }
 
+function containsTimedGoal(goal) {
+  const stack = [goal];
+  while (stack.length !== 0) {
+    const term = stack.pop();
+    if (term?.type !== 'compound') continue;
+    if (term.name === 'time' && term.arity === 1) return true;
+    for (let index = term.args.length - 1; index >= 0; index--) stack.push(term.args[index]);
+  }
+  return false;
+}
+
 function pullSolution(solver, solutions, reader) {
   const stream = solver.io.resolve('user_output');
   const originalWrite = stream?.write;

package/src/solver.js

@@ -58,6 +58,10 @@ export class Solver {
     this.depthLimitExceeded = false;
     this.maxInferences = options.maxInferences ?? Infinity;
     this.inferences = 0;
+    // Shared only for observability: nested meta-call solvers contribute to the
+    // same measurement counter without changing each solver's local inference
+    // limit accounting. time/1 snapshots this counter around the measured goal.
+    this.inferenceObservation = options.inferenceObservation ?? { value: 0 };
     this.inferenceLimitExceeded = false;
     this.maxMemoryBytes = options.maxMemoryBytes ?? softHeapLimit();
     this.memoryRecovery = options.memoryRecovery ?? {
@@ -158,6 +162,7 @@ export class Solver {
       charConversions: this.charConversions,
       io: this.io,
       innerTableScopes: this.innerTableScopes,
+      inferenceObservation: this.inferenceObservation,
       skipListTailTabling: options.skipListTailTabling ?? this.skipListTailTabling,
     });
     if (options.tableScope != null) {
@@ -282,6 +287,7 @@ export class Solver {
       this.solveStacks.push(stack);
       while (stack.length) {
       this.inferences++;
+      this.inferenceObservation.value++;
       this.checkMemoryLimit();
       if (this.inferences > this.maxInferences) {
         this.inferenceLimitExceeded = true;
@@ -334,6 +340,7 @@ export class Solver {
 
       while (true) {
         this.inferences++;
+        this.inferenceObservation.value++;
         this.checkMemoryLimit();
         if (this.inferences > this.maxInferences) {
           this.inferenceLimitExceeded = true;
@@ -388,6 +395,7 @@ export class Solver {
         const selectedIndex = selectReadyDeterministicBuiltin(goals, env, this.registry);
         const goal = deref(goals[selectedIndex], env);
         const rest = selectedIndex === 0 ? goals.slice(1) : [...goals.slice(0, selectedIndex), ...goals.slice(selectedIndex + 1)];
+        prepareLocalVariablesForGoal(goal, env);
         if (goal.type === 'atom' && goal.name === '!' && goal.arity === 0) {
           const marker = active[active.length - 1] ?? null;
           if (marker) marker.cutEpoch = (marker.cutEpoch ?? 0) + 1;
@@ -539,6 +547,23 @@ export class Solver {
           continue;
         }
 
+        const ellipsisPlan = bundledEllipsisPlan(this, group, goal, rest, env);
+        if (ellipsisPlan != null) {
+          const firstResult = ellipsisPlan.iterator.next();
+          if (firstResult.done) break;
+          stack.push({
+            kind: 'resumeBuiltin',
+            iterator: ellipsisPlan.iterator,
+            goals: ellipsisPlan.rest,
+            depth: depth + 1,
+            active,
+          });
+          goals = ellipsisPlan.rest;
+          env = firstResult.value;
+          depth++;
+          continue;
+        }
+
         if (group.tabled && !(this.skipListTailTabling && group.listTailRecursive)) {
           const key = memoKey(goal, env, group);
           if (key.hasBound) {
@@ -612,6 +637,13 @@ export class Solver {
     }
   }
 
+  hasPendingAlternatives() {
+    // When solve() is suspended at an answer, active solve stacks contain only
+    // unexplored work. The timed REPL path uses this without speculatively
+    // pulling the next answer.
+    return this.solveStacks.some((stack) => stack.length !== 0);
+  }
+
   fastCountGoal(goal, env) {
     return fastCountPureGoal(this, goal, env);
   }
@@ -804,7 +836,7 @@ export class Solver {
         attachBodyLocalFreshVariables(freshBody, localFreshPlan.body, freshVariables);
         const next = env.clone();
         this.stats.unify_calls++;
-        if (!unify(goal, freshHead, next, { localFreshVariables: headLocalFresh })) continue;
+        if (!unify(goal, freshHead, next, { knownNonoccurringVariables: headLocalFresh })) continue;
         if (freshBody.length === 0) {
           yield* this.solve(rest, next, depth + 1);
         } else if (!groupNeedsActiveFrame(group)) {
@@ -1021,7 +1053,7 @@ function pushUserGoalUncachedFrames(stack, solver, group, goal, rest, env, depth
       attachBodyLocalFreshVariables(freshBody, localFreshPlan.body, freshVariables);
       const next = env.clone();
       solver.stats.unify_calls++;
-      if (!unify(goal, freshHead, next, { localFreshVariables: headLocalFresh })) continue;
+      if (!unify(goal, freshHead, next, { knownNonoccurringVariables: headLocalFresh })) continue;
       if (freshBody.length === 0) {
         frames.push({
           kind: 'goals',
@@ -1083,12 +1115,47 @@ function freshVariableSet(names, freshVariables) {
 
 function attachBodyLocalFreshVariables(freshBody, plan, freshVariables) {
   for (let index = 0; index < freshBody.length; index++) {
-    const localFreshVariables = freshVariableSet(plan[index] ?? [], freshVariables);
-    if (localFreshVariables != null && freshBody[index]?.type === COMPOUND &&
-        freshBody[index].name === '=' && freshBody[index].arity === 2) {
-      freshBody[index]._localFreshVariables = localFreshVariables;
+    const goal = freshBody[index];
+    const knownNonoccurringVariables = freshVariableSet(plan[index] ?? [], freshVariables);
+    if (knownNonoccurringVariables == null || goal?.type !== COMPOUND) continue;
+    if (goal.name === '=' && goal.arity === 2) {
+      goal._knownNonoccurringVariables = knownNonoccurringVariables;
+      continue;
+    }
+    // Only a compiler-generated DCG state first handed as a complete argument
+    // to another callable receives a longer-lived local marker. Equality-created
+    // sequence variables keep the existing one-unification proof instead.
+    const localFirstUseVariables = new Set();
+    for (const argument of goal.args) {
+      if (argument?.type === VAR && argument.name.startsWith('\u0000dcg') &&
+          knownNonoccurringVariables.has(argument.name)) {
+        localFirstUseVariables.add(argument.name);
+      }
+    }
+    if (localFirstUseVariables.size !== 0) goal._localFirstUseVariables = localFirstUseVariables;
+  }
+}
+
+
+function prepareLocalVariablesForGoal(goal, env) {
+  // A DCG local is globalized if later source places it inside a structure.
+  // Inspect the small fresh goal syntax rather than dereferencing large data.
+  if (env.hasLocalVariables() && goal?.type === COMPOUND) {
+    const pending = [];
+    for (const argument of goal.args) if (argument?.type === COMPOUND) pending.push(argument);
+    while (pending.length !== 0) {
+      const current = pending.pop();
+      for (const argument of current.args ?? []) {
+        if (argument?.type === VAR) {
+          const root = derefForLocal(argument, env);
+          if (root.type === VAR && env.isLocalVariable(root.name)) env.demoteLocalVariable(root.name);
+        } else if (argument?.type === COMPOUND) {
+          pending.push(argument);
+        }
+      }
     }
   }
+  env.markLocalVariables(goal?._localFirstUseVariables ?? null);
 }
 
 function groupNeedsActiveFrame(group) {
@@ -1176,6 +1243,92 @@ function* bundledMemberSolutions(solver, goal, env) {
   }
 }
 
+function bundledEllipsisPlan(solver, group, goal, rest, env) {
+  if (solver.registry.eyePrologLibrary !== true ||
+      group.module !== 'iso_ext' || group.name !== '...' || group.arity !== 2 ||
+      group.bundledLibrary !== true || group.clauses.length !== 2) {
+    return null;
+  }
+
+  // length/2 and other native constructors can leave a known finite list as a
+  // compact spine.  The ordinary ...//0 relation simply enumerates every
+  // suffix of such a list; doing that directly avoids clause freshening and
+  // recursive solver depth for every consumed element.  Non-compact and open
+  // list cases retain the ordinary Prolog definition.
+  const input = deref(goal.args[0], env);
+  if (compactListLength(input) == null) return null;
+
+  // A following binary identity relation is just a zero-width DCG hand-off.
+  // Fuse it by asking .../2 for that relation's required output directly.
+  // This is a structural optimization: any one-clause p(X,Y):-X=Y (or p(X,X).)
+  // qualifies, not just a predicate named epsilon/2.
+  if (rest.length > 0) {
+    const continuation = deref(rest[0], env);
+    if (continuation?.type === COMPOUND && continuation.arity === 2) {
+      const continuationGroup = solver.program.findGroup(
+        continuation.name, continuation.arity, continuation.module ?? goal.module ?? 'user',
+      );
+      if (isBinaryIdentityGroup(continuationGroup)) {
+        const output = deref(goal.args[1], env);
+        const continuationInput = deref(continuation.args[0], env);
+        if (output.type === VAR && continuationInput.type === VAR && output.name === continuationInput.name &&
+            output.name.startsWith('\u0000dcg')) {
+          return {
+            iterator: bundledEllipsisSolutions(solver, continuation.args[1], input, env),
+            rest: rest.slice(1),
+          };
+        }
+      }
+    }
+  }
+
+  return { iterator: bundledEllipsisSolutions(solver, goal.args[1], input, env), rest };
+}
+
+function isBinaryIdentityGroup(group) {
+  if (group == null || group.arity !== 2 || group.clauses.length !== 1 || group.hasCut === true) return false;
+  const clause = group.clauses[0];
+  const left = clause.head?.args?.[0];
+  const right = clause.head?.args?.[1];
+  if (left?.type !== VAR || right?.type !== VAR) return false;
+  if (clause.body.length === 0) return left.name === right.name;
+  if (clause.body.length !== 1) return false;
+  const equality = clause.body[0];
+  if (equality?.type !== COMPOUND || equality.name !== '=' || equality.arity !== 2) return false;
+  const a = equality.args[0];
+  const b = equality.args[1];
+  if (a?.type !== VAR || b?.type !== VAR) return false;
+  return (a.name === left.name && b.name === right.name) ||
+    (a.name === right.name && b.name === left.name);
+}
+
+function* bundledEllipsisSolutions(solver, output, input, env) {
+  let cursor = input;
+  const requestedOutput = deref(output, env);
+
+  // A fixed empty remainder is the important DCG scanner case. Still walk the
+  // actual compact spine so this remains a real tail-consumption benchmark,
+  // but avoid allocating a speculative environment for every suffix that is
+  // structurally incapable of matching [].
+  if (isEmptyList(requestedOutput)) {
+    while (!isEmptyList(cursor)) {
+      if (!isCons(cursor)) return;
+      cursor = deref(cursor.args[1], env);
+    }
+    yield env;
+    return;
+  }
+
+  while (true) {
+    const next = env.clone();
+    solver.stats.unify_calls++;
+    if (unify(output, cursor, next)) yield next;
+    if (isEmptyList(cursor)) return;
+    if (!isCons(cursor)) return;
+    cursor = deref(cursor.args[1], env);
+  }
+}
+
 function bundledLengthIterator(solver, group, goal, env) {
   if (solver.registry.eyePrologLibrary !== true ||
       !['lists', 'prologue'].includes(group.module) || group.name !== 'length' || group.arity !== 2 ||
@@ -1257,12 +1410,11 @@ function* fixedLengthSolutions(solver, list, length, env) {
   const suffix = compactVariableList(remaining, `__length${id}_`);
   const next = env.clone();
   solver.stats.unify_calls++;
-  // 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;
+  // The compact skeleton contains only freshly generated variables, so the
+  // dereferenced tail variable is known not to occur in it. Reuse the same
+  // proven-nonoccurrence path as source-level first-use unification.
+  const knownNonoccurringVariables = new Set([cursor.name]);
+  if (unify(cursor, suffix, next, { knownNonoccurringVariables })) yield next;
 }
 
 function* generatedLengthSolutions(solver, list, length, env) {
@@ -1296,15 +1448,13 @@ function* generatedLengthSolutions(solver, list, length, env) {
 
   const id = nextFreshId();
   let suffix = emptyList();
+  // Every generated suffix is built from fresh variables and therefore cannot
+  // contain the caller's dereferenced tail variable. Share the general
+  // proven-nonoccurrence unification path instead of bypassing unify() here.
+  const knownNonoccurringVariables = new Set([cursor.name]);
   for (let extra = 0n; ; extra++) {
     const next = env.clone();
-    // cursor is a dereferenced plain variable and suffix is made only from
-    // freshly generated variables, so this binding cannot create a cycle.
-    // Binding directly avoids an O(extra) occurs-check over the complete
-    // growing suffix for every answer; without this, unbounded length/2
-    // generation becomes quadratic and can spend hours before reaching the
-    // normal memory resource guard (issue #49).
-    next.bind(cursor.name, suffix);
+    if (!unify(cursor, suffix, next, { knownNonoccurringVariables })) return;
     const answer = bindGeneratedLength(solver, length, count + extra, next);
     if (answer != null) yield answer;
     suffix = cons(variable(`__length${id}_${extra}`), suffix);
@@ -2395,7 +2545,7 @@ function selectReadyDeterministicBuiltin(goals, env, registry) {
     // 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.
-    if (goal?._localFreshVariables != null) return 0;
+    if (goal?._knownNonoccurringVariables != null) return 0;
     if (goal.type !== COMPOUND && goal.type !== 'atom') continue;
     const def = registry.get(goal.name, goal.arity);
     if (!def?.deterministic || typeof def.ready !== 'function') continue;

package/src/standard-library.js

@@ -47,7 +47,7 @@ function libraryUrl(filename) {
 }
 
 export const eyePrologNativeLibraryIndicators = Object.freeze([
-  'call_nth/2', 'freeze/2', 'countall/2',
+  'call_nth/2', 'freeze/2', 'countall/2', 'time/1',
   '#>/2', '#</2', '#>=/2', '#=</2', '#=/2', '#\\=/2', '#\\/1',
   '#<==>/2', '#==>/2', '#<==/2', '#\\//2', '#\\/2', '#/\\/2',
   'in/2', 'ins/2', 'all_different/1', 'all_distinct/1', 'nvalue/2', 'sum/3',
@@ -68,7 +68,7 @@ export const eyePrologPortableLibraryIndicators = Object.freeze([
   'nth0/3', 'nth0/4', 'nth1/3', 'nth1/4', 'set_nth0/4', 'take/3', 'drop/3', 'slice/4', 'reverse/2',
   'length/2', 'sum_list/2', 'min_list/2', 'max_list/2', 'list_to_set/2',
   'succ/2', 'foldl/4', 'foldl/5', 'foldl/6',
-  'forall/2', 'cfor/3', 'findall/4', 'variant/2', 'uuid/3',
+  'forall/2', 'cfor/3', 'findall/4', 'variant/2', '.../2', 'uuid/3',
   '^/3', '^/4', '^/5', '^/6', '^/7', '^/8', '^/9', '^/10',
   '\\/1', '\\/2', '\\/3', '\\/4', '\\/5', '\\/6', '\\/7', '\\/8',
   '+\\/2', '+\\/3', '+\\/4', '+\\/5', '+\\/6', '+\\/7', '+\\/8', '+\\/9',
@@ -117,6 +117,11 @@ export const eyePrologInteropAutoload = Object.freeze({
   // it from library(iso_ext), matching the explicit Scryer import while still
   // allowing Trealla-style unqualified source to use the same autoload entry.
   'call_nth/2': 'iso_ext',
+  // Trealla exposes time/1 as a meta timing predicate and library(iso_ext)
+  // supplies ...//0. Autoload both so UWN's DCG hand-off benchmark runs
+  // unchanged while their implementations remain outside the ISO core.
+  'time/1': 'iso_ext',
+  '.../2': 'iso_ext',
   // Trealla and Scryer expose between/3 without an EyeProlog-style
   // library(prologue) dependency.  EyeProlog keeps its implementation in the
   // Prologue module but autoloads it so portable source need not name that