eyeprolog 1.3.13 → 1.3.15

package/README.md

@@ -201,8 +201,25 @@ 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
+For a larger bidirectional example, see
+[`examples/dcg-expression-language.pl`](examples/dcg-expression-language.pl).
+It parses precedence-sensitive arithmetic into an AST, evaluates expressions
+with variables, generates tokens back from an AST with only the necessary
+parentheses, round-trips the generated form, and demonstrates `phrase/3`
+remainder handling.  The example uses accumulator nonterminals for
+left-associative operators, so state is handed repeatedly from one nonterminal
+to the next rather than hidden in host code.
+
+Deep finite DCG traversal is kept relational but does not have to consume one
+general solver frame per token.  In particular, the interoperable `...//0`
+helper from `library(iso_ext)` can scan a finite compact list iteratively, and a
+following grammar that is statically known to leave the DCG state unchanged can
+be continued without rebuilding a full clause-resolution frame for every
+suffix.  Open and remainder-producing uses still retain the ordinary DCG
+solutions and backtracking behavior.
+
+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
@@ -225,8 +242,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/examples/dcg-expression-language.pl

@@ -0,0 +1,147 @@
+% Parse, evaluate, and regenerate arithmetic expressions with a DCG.
+%
+% The parser builds an AST while respecting precedence and left associativity.
+% The additive_tail//2 and multiplicative_tail//2 nonterminals use an
+% accumulator instead of left recursion.  A second DCG pretty-prints an AST
+% with only the parentheses required to preserve its structure, making the
+% example useful in both directions.
+%% goal: dcg_expression_example(X0, X1)
+
+% expression//1: + and - are the lowest-precedence operators.
+expression(AST) -->
+  term(First),
+  additive_tail(First, AST).
+
+additive_tail(Left, AST) -->
+  ['+'],
+  term(Right),
+  { Next = add(Left, Right) },
+  additive_tail(Next, AST).
+additive_tail(Left, AST) -->
+  ['-'],
+  term(Right),
+  { Next = sub(Left, Right) },
+  additive_tail(Next, AST).
+additive_tail(AST, AST) --> [].
+
+% term//1: * and / bind more tightly than + and -.
+term(AST) -->
+  unary(First),
+  multiplicative_tail(First, AST).
+
+multiplicative_tail(Left, AST) -->
+  ['*'],
+  unary(Right),
+  { Next = mul(Left, Right) },
+  multiplicative_tail(Next, AST).
+multiplicative_tail(Left, AST) -->
+  ['/'],
+  unary(Right),
+  { Next = div(Left, Right) },
+  multiplicative_tail(Next, AST).
+multiplicative_tail(AST, AST) --> [].
+
+% Unary minus nests, so --x is represented as neg(neg(var(x))).
+unary(neg(AST)) --> ['-'], unary(AST).
+unary(AST) --> primary(AST).
+
+primary(lit(Number)) -->
+  [Number],
+  { number(Number) }.
+primary(var(Name)) -->
+  [Name],
+  { variable_name(Name) }.
+primary(AST) --> ['('], expression(AST), [')'].
+
+variable_name(x).
+variable_name(y).
+variable_name(z).
+
+% A small evaluator for the AST produced by the grammar.
+evaluate(lit(Number), _, Number).
+evaluate(var(Name), Environment, Value) :-
+  lookup(Name, Environment, Value).
+evaluate(neg(AST), Environment, Value) :-
+  evaluate(AST, Environment, Inner),
+  Value is -Inner.
+evaluate(add(Left, Right), Environment, Value) :-
+  evaluate(Left, Environment, L),
+  evaluate(Right, Environment, R),
+  Value is L + R.
+evaluate(sub(Left, Right), Environment, Value) :-
+  evaluate(Left, Environment, L),
+  evaluate(Right, Environment, R),
+  Value is L - R.
+evaluate(mul(Left, Right), Environment, Value) :-
+  evaluate(Left, Environment, L),
+  evaluate(Right, Environment, R),
+  Value is L * R.
+evaluate(div(Left, Right), Environment, Value) :-
+  evaluate(Left, Environment, L),
+  evaluate(Right, Environment, R),
+  Value is L / R.
+
+lookup(Name, [Name-Value|_], Value).
+lookup(Name, [_|Rest], Value) :-
+  lookup(Name, Rest, Value).
+
+% Precedence-aware generation.  The right operand is emitted at a stricter
+% minimum precedence than the left operand, preserving left associativity.
+emit_expression(AST) --> emit(AST, 0).
+
+emit(AST, Minimum) -->
+  { precedence(AST, Precedence),
+    parenthesize(Precedence, Minimum, Wrap) },
+  emit_wrapped(Wrap, AST).
+
+emit_wrapped(yes, AST) --> ['('], emit_node(AST), [')'].
+emit_wrapped(no, AST) --> emit_node(AST).
+
+emit_node(lit(Number)) --> [Number].
+emit_node(var(Name)) --> [Name].
+emit_node(neg(AST)) --> ['-'], emit(AST, 30).
+emit_node(add(Left, Right)) -->
+  emit(Left, 10), ['+'], emit(Right, 11).
+emit_node(sub(Left, Right)) -->
+  emit(Left, 10), ['-'], emit(Right, 11).
+emit_node(mul(Left, Right)) -->
+  emit(Left, 20), ['*'], emit(Right, 21).
+emit_node(div(Left, Right)) -->
+  emit(Left, 20), ['/'], emit(Right, 21).
+
+precedence(add(_, _), 10).
+precedence(sub(_, _), 10).
+precedence(mul(_, _), 20).
+precedence(div(_, _), 20).
+precedence(neg(_), 30).
+precedence(lit(_), 40).
+precedence(var(_), 40).
+
+parenthesize(Precedence, Minimum, yes) :- Precedence < Minimum.
+parenthesize(Precedence, Minimum, no) :- Precedence >= Minimum.
+
+% Parse a mixed-precedence expression.
+dcg_expression_example(parsed, AST) :-
+  phrase(expression(AST),
+         [2, '+', 3, '*', '(', 4, '-', 1, ')']).
+
+% Evaluate a parsed expression with variables.
+dcg_expression_example(evaluated, Value) :-
+  phrase(expression(AST), [x, '*', '(', y, '+', 2, ')', '-', z]),
+  evaluate(AST, [x-4, y-3, z-1], Value).
+
+% Generate the minimal parentheses needed to preserve a right-nested
+% subtraction tree, then parse the generated tokens back to the same AST.
+dcg_expression_example(round_trip, Tokens) :-
+  AST = sub(lit(20), sub(lit(5), lit(3))),
+  phrase(emit_expression(AST), Tokens),
+  phrase(expression(AST), Tokens).
+
+% phrase/3 lets a larger language parse an expression prefix and keep the rest.
+dcg_expression_example(remainder, Rest) :-
+  phrase(expression(mul(var(x), lit(2))),
+         [x, '*', 2, then, stop], Rest).
+
+% Missing closing parentheses are rejected.
+dcg_expression_example(rejected, malformed_parentheses) :-
+  \+ phrase(expression(_), [2, '*', '(', 3, '+', 4]).

package/examples/output/dcg-expression-language.pl

@@ -0,0 +1,5 @@
+dcg_expression_example(parsed, add(lit(2), mul(lit(3), sub(lit(4), lit(1))))).
+dcg_expression_example(evaluated, 19).
+dcg_expression_example(round_trip, [20, -, '(', 5, -, 3, ')']).
+dcg_expression_example(remainder, [then, stop]).
+dcg_expression_example(rejected, malformed_parentheses).

package/package.json

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

package/playground.html

@@ -481,6 +481,7 @@
           "critical-path-schedule",
           "cyclic-path",
           "dcg-command-parser",
+          "dcg-expression-language",
           "d3-group",
           "dairy-energy-balance",
           "data-negotiation",

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,6 +176,8 @@ 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 });
   },
 };
 
@@ -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);
   }
@@ -1083,12 +1115,47 @@ function freshVariableSet(names, freshVariables) {
 
 function attachBodyLocalFreshVariables(freshBody, plan, freshVariables) {
   for (let index = 0; index < freshBody.length; index++) {
+    const goal = freshBody[index];
     const knownNonoccurringVariables = freshVariableSet(plan[index] ?? [], freshVariables);
-    if (knownNonoccurringVariables != null && freshBody[index]?.type === COMPOUND &&
-        freshBody[index].name === '=' && freshBody[index].arity === 2) {
-      freshBody[index]._knownNonoccurringVariables = knownNonoccurringVariables;
+    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 ||

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

package/src/term.js

@@ -99,6 +99,7 @@ export class Env {
     this._delays = null;
     this._clpz = null;
     this._occursCheckHandler = null;
+    this._localVariables = null;
   }
   clone() {
     // Most speculative environments are either rejected without a binding or
@@ -111,12 +112,43 @@ export class Env {
     clone._delays = this._delays;
     clone._clpz = this._clpz;
     clone._occursCheckHandler = this._occursCheckHandler;
+    clone._localVariables = this._localVariables;
     return clone;
   }
   setOccursCheckHandler(handler) {
     this._occursCheckHandler = typeof handler === 'function' ? handler : null;
     return this;
   }
+  hasLocalVariables() {
+    return this._localVariables != null && this._localVariables.size !== 0;
+  }
+  isLocalVariable(name) {
+    return this._localVariables?.has(name) === true;
+  }
+  markLocalVariables(names) {
+    if (names == null || names.size === 0) return;
+    let next = this._localVariables;
+    for (const name of names) {
+      const root = deref(variable(name), this);
+      if (root.type !== VAR || next?.has(root.name)) continue;
+      if (next === this._localVariables) next = new Set(this._localVariables ?? []);
+      next.add(root.name);
+    }
+    this._localVariables = next;
+  }
+  demoteLocalVariable(name) {
+    const root = deref(variable(name), this);
+    if (root.type !== VAR || this._localVariables?.has(root.name) !== true) return;
+    const next = new Set(this._localVariables);
+    next.delete(root.name);
+    this._localVariables = next.size === 0 ? null : next;
+  }
+  forgetLocalVariable(name) {
+    if (this._localVariables?.has(name) !== true) return;
+    const next = new Set(this._localVariables);
+    next.delete(name);
+    this._localVariables = next.size === 0 ? null : next;
+  }
   has(name) {
     return this.get(name) !== undefined;
   }
@@ -212,6 +244,9 @@ export function deref(term, env) {
   let current = term;
   let seen = null;
   while (current?.type === VAR) {
+    // A live compiler-proven DCG local is the current unbound representative.
+    // No older Env layer can contain a binding for it.
+    if (env?.isLocalVariable?.(current.name) === true) break;
     const next = env?.get(current.name);
     if (next === undefined) break;
     if (seen?.has(current.name)) break;
@@ -284,28 +319,40 @@ export function unify(left, right, env, options = {}) {
 
     if (a.type === VAR && b.type === VAR && a.name === b.name) continue;
     if (a.type === VAR && b.type === VAR) {
-      // Both variables are already dereferenced and unbound, so linking them
-      // cannot create a cycle and needs no occurs-check traversal.
-      markCompactVariableBound(a);
-      env.bind(a.name, b);
+      // For a compiler-generated DCG state handed directly to another
+      // nonterminal, keep the local caller variable as representative. Ordinary
+      // aliases retain the established direction and observable conventions.
+      const aLocalDcg = env?.isLocalVariable(a.name) === true &&
+        a.name.startsWith('\u0000dcg') && b.name.startsWith('\u0000dcg');
+      if (aLocalDcg) {
+        markCompactVariableBound(b);
+        env.bind(b.name, a);
+      } else {
+        markCompactVariableBound(a);
+        env.bind(a.name, b);
+      }
       continue;
     }
     if (a.type === VAR) {
-      if (!knownNonoccurringVariables?.has(a.name) && occurs(a.name, b, env)) {
+      const aLocal = env?.isLocalVariable(a.name) === true;
+      if (!aLocal && !knownNonoccurringVariables?.has(a.name) && occurs(a.name, b, env)) {
         occursCheckHandler?.(a, b, env);
         return false;
       }
       markCompactVariableBound(a);
       env.bind(a.name, b);
+      if (aLocal) env.forgetLocalVariable(a.name);
       continue;
     }
     if (b.type === VAR) {
-      if (!knownNonoccurringVariables?.has(b.name) && occurs(b.name, a, env)) {
+      const bLocal = env?.isLocalVariable(b.name) === true;
+      if (!bLocal && !knownNonoccurringVariables?.has(b.name) && occurs(b.name, a, env)) {
         occursCheckHandler?.(b, a, env);
         return false;
       }
       markCompactVariableBound(b);
       env.bind(b.name, a);
+      if (bLocal) env.forgetLocalVariable(b.name);
       continue;
     }
 

package/test/run-regression.mjs

@@ -1324,6 +1324,9 @@ c4 ?- call((!;1)).
           first_use_cycle :- X = f(Y), Y = g(X).
           repeated_cycle :- X = f(X).
           first_use_ok(T) :- X = f(Y), Y = a, T = X.
+          pass(_).
+          handed_off_cycle :- pass(X), Y = f(X), X = g(Y).
+          handed_off_alias_cycle :- pass(X), Y = X, X = f(Y).
         `);
         const solver = new Solver(program);
         const solveCount = (text) => {
@@ -1338,6 +1341,8 @@ c4 ?- call((!;1)).
         assertEqual(solveCount('first_use_cycle'), 0, 'cycle across later first-use binding');
         assertEqual(solveCount('repeated_cycle'), 0, 'same-goal repeated variable still checks occurs');
         assertEqual(solveCount('first_use_ok(f(a))'), 1, 'acyclic first-use bindings still succeed');
+        assertEqual(solveCount('handed_off_cycle'), 0, 'nested use globalizes a handed-off local before a cycle');
+        assertEqual(solveCount('handed_off_alias_cycle'), 0, 'aliasing does not hide a later cycle');
       },
     },
     {
@@ -1379,6 +1384,106 @@ c4 ?- call((!;1)).
         assertEqual(result.stdout, 'ok', 'deep DCG result');
       },
     },
+    {
+      name: 'Trealla-style DCG hand-off autoloads time/1 and ...//0 without quadratic occurs checks (issue #49)',
+      run: () => {
+        const engineUrl = new URL('../src/index.js', import.meta.url).href;
+        const script = `
+          import { run } from ${JSON.stringify(engineUrl)};
+          const source = ${JSON.stringify('a --> ..., epsilon.\nepsilon --> [].\n')};
+          const result = run(source, {
+            goal: ${JSON.stringify('length(_,E), E>12, N is 2^E, \\+ \\+ (length(L,N), time(phrase(a,L)))')},
+            solutionLimit: 1,
+          });
+          if (!result.stdout.startsWith('% Time elapsed ') || !result.stdout.endsWith('s\\n')) {
+            throw new Error('unexpected time/1 output: ' + JSON.stringify(result.stdout));
+          }
+          process.stdout.write('ok');
+        `;
+        const result = spawnSync(process.execPath, ['--input-type=module', '--eval', script], {
+          cwd: packageRoot,
+          encoding: 'utf8',
+          timeout: 10000,
+        });
+        if (result.error) throw result.error;
+        assertEqual(result.status, 0, `DCG hand-off child status; stderr=${result.stderr}`);
+        assertEqual(result.stdout, 'ok', 'DCG hand-off benchmark result');
+      },
+    },
+    {
+      name: 'Trealla-style DCG hand-off reaches 65536 cells without the solver depth ceiling',
+      run: () => {
+        const engineUrl = new URL('../src/index.js', import.meta.url).href;
+        const script = `
+          import { run } from ${JSON.stringify(engineUrl)};
+          const source = ${JSON.stringify(':- set_prolog_flag(occurs_check, true).\na --> ..., epsilon.\nepsilon --> [].\n')};
+          const result = run(source, {
+            goal: ${JSON.stringify('\\+ \\+ (length(L,65536), time(phrase(a,L)))')},
+            solutionLimit: 1,
+          });
+          if (!result.stdout.startsWith('% Time elapsed ')) {
+            throw new Error('65536-cell hand-off did not succeed: ' + JSON.stringify(result.stdout));
+          }
+          process.stdout.write('ok');
+        `;
+        const result = spawnSync(process.execPath, ['--input-type=module', '--eval', script], {
+          cwd: packageRoot,
+          encoding: 'utf8',
+          timeout: 5000,
+        });
+        if (result.error) throw result.error;
+        assertEqual(result.status, 0, `65536-cell hand-off status; stderr=${result.stderr}`);
+        assertEqual(result.stdout, 'ok', '65536-cell hand-off result');
+      },
+    },
+    {
+      name: 'REPL applies conservative autoloading to interactive time/1 and consulted ...//0',
+      run: () => {
+        const filename = path.join(tmp, `issue49-handoff-${tmpCounter++}.pl`);
+        fs.writeFileSync(filename, 'a --> ..., epsilon.\nepsilon --> [].\n');
+        const result = runCli([], {
+          input:
+            `[${sourceAtom(filename)}].\n` +
+            'use_module(library(lists)).\n' +
+            'length(_,E),E>12,N is 2^E,\\+ \\+ (length(L,N),time(phrase(a,L))).\n' +
+            '\n' +
+            'halt.\n',
+          timeout: 10000,
+        });
+        if (result.error) throw result.error;
+        assertEqual(result.status, 0, `REPL hand-off status; stderr=${result.stderr}`);
+        assertIncludes(result.stdout, '% Time elapsed ', 'REPL time/1 output');
+        assertEqual((result.stdout.match(/% Time elapsed /g) ?? []).length, 1,
+          'REPL timed query does not prefetch an unrequested next answer');
+        assertIncludes(result.stdout, 'E = 13, N = 8192', 'REPL first benchmark answer');
+        assertNotIncludes(result.stdout, 'existence_error(procedure', 'REPL autoload errors');
+        assertEqual(result.stderr, '', 'REPL hand-off stderr');
+      },
+    },
+    {
+      name: 'REPL Trealla hand-off benchmark reaches E=16 on demand without OOM fallthrough',
+      run: () => {
+        const filename = path.join(tmp, `issue49-handoff-deep-${tmpCounter++}.pl`);
+        fs.writeFileSync(filename, ':- set_prolog_flag(occurs_check, true).\na --> ..., epsilon.\nepsilon --> [].\n');
+        const result = runCli([], {
+          input:
+            `[${sourceAtom(filename)}].\n` +
+            'use_module(library(lists)).\n' +
+            'length(_,E),E>12,N is 2^E,\\+ \\+ (length(L,N),time(phrase(a,L))).\n' +
+            ';\n;\n;\n\n' +
+            'halt.\n',
+          timeout: 5000,
+        });
+        if (result.error) throw result.error;
+        assertEqual(result.status, 0, `deep REPL hand-off status; stderr=${result.stderr}`);
+        for (const [e, n] of [[13, 8192], [14, 16384], [15, 32768], [16, 65536]]) {
+          assertIncludes(result.stdout, `E = ${e}, N = ${n}`, `REPL hand-off E=${e}`);
+        }
+        assertEqual((result.stdout.match(/% Time elapsed /g) ?? []).length, 4,
+          'exactly four requested timed answers');
+        assertEqual(result.stderr, '', 'deep REPL hand-off stderr');
+      },
+    },
     {
       name: 'REPL enumerates and stops answers like the Scryer top level',
       run: () => {
@@ -3916,7 +4021,7 @@ 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, 156, 'EyeProlog registry contains ISO definitions, observability extensions, WFS tnot/1, and private library adapters');
+        assertEqual(library.defs.size, 158, 'EyeProlog registry contains ISO definitions, observability extensions, WFS tnot/1, and private library adapters');
         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');
@@ -3925,17 +4030,21 @@ answer(ok) :-
         assertEqual(Boolean(library.get('statistics', 2)), true, 'statistics/2 is an EyeProlog observability extension');
         assertEqual(registry.get('tnot', 1), null, 'tnot/1 is absent from the ISO registry');
         assertEqual(Boolean(library.get('tnot', 1)), true, 'tnot/1 is an EyeProlog WFS extension');
-        assertEqual(registeredNativeEyePrologLibraryNames().length, 40, 'public native EyeProlog builtin count');
-        assertEqual(eyePrologPortableLibraryIndicators.length, 86, 'portable Prolog library count');
-        assertEqual(eyePrologInteropLibraryIndicators.length, 27, 'cross-implementation interop profile count');
+        assertEqual(registry.get('time', 1), null, 'time/1 is absent from the ISO registry');
+        assertEqual(Boolean(library.get('time', 1)), true, 'time/1 is an EyeProlog timing extension');
+        assertEqual(registeredNativeEyePrologLibraryNames().length, 41, 'public native EyeProlog builtin count');
+        assertEqual(eyePrologPortableLibraryIndicators.length, 87, 'portable Prolog library count');
+        assertEqual(eyePrologInteropLibraryIndicators.length, 29, 'cross-implementation interop profile count');
         assertEqual(eyePrologInteropLibraryModules.join(','), 'lists,iso_ext,lambda', 'common explicit library module profile');
         assertEqual(eyePrologInteropAutoload['member/2'], 'lists', 'member/2 canonical autoload');
         assertEqual(eyePrologInteropAutoload['between/3'], 'prologue', 'between/3 canonical internal autoload');
         assertEqual(eyePrologInteropAutoload['call_nth/2'], 'iso_ext', 'call_nth/2 canonical interop autoload');
+        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, 40, 'native host library count');
+        assertEqual(eyePrologNativeLibraryIndicators.length, 41, 'native host library count');
         assertEqual(eyePrologNativeLibraryIndicators.slice(0, 2).join(','), 'call_nth/2,freeze/2', 'control predicates requiring host support');
-        assertEqual(eyePrologLibraryIndicators.length, 126, 'complete EyeProlog library surface');
+        assertEqual(eyePrologLibraryIndicators.length, 128, 'complete 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(library.get('eyeprolog__call_nth', 2)?.eyePrologLibrary, true, 'private adapter is marked as library support');
@@ -3943,6 +4052,7 @@ answer(ok) :-
         assertEqual(Boolean(library.get('eyeprolog__freeze', 2)), true, 'private freeze adapter is registered for EyeProlog');
         assertEqual(registry.get('eyeprolog__countall', 2), null, 'private countall adapter is absent from ISO registry');
         assertEqual(Boolean(library.get('eyeprolog__countall', 2)), true, 'private countall adapter is registered for EyeProlog');
+        assertEqual(Boolean(library.get('eyeprolog__time', 1)), true, 'private time adapter is registered for EyeProlog');
         assertEqual(Boolean(library.get('eyeprolog__clpz_labeling', 2)), true, 'private CLP(Z) labeling adapter is registered');
         assertEqual(Boolean(library.get('eyeprolog__clpz_global_cardinality', 3)), true, 'private CLP(Z) cardinality adapter is registered');
         assertEqual(library.get('between', 3), null, 'between/3 remains portable Prolog');

package/the-art-of-eyeprolog.md

@@ -5632,6 +5632,62 @@ that argument. A variable body raises `instantiation_error`; a non-callable
 body raises `type_error(callable)`. EyeProlog performs terminal-sequence checks
 and reports the portable ISO `type_error(list)` error term.
 
+#### A bidirectional expression grammar
+
+DCGs become more useful when the grammar produces a structured term rather than
+merely accepting a token list.  The checked
+[`dcg-expression-language.pl`](https://github.com/eyereasoner/eyeprolog/blob/main/examples/dcg-expression-language.pl)
+example implements a small arithmetic language in both directions.  Its parser
+respects precedence and left associativity while constructing an abstract syntax
+tree:
+
+```text
+expression(AST) -->
+  term(First),
+  additive_tail(First, AST).
+
+additive_tail(Left, AST) -->
+  ['+'], term(Right),
+  { Next = add(Left, Right) },
+  additive_tail(Next, AST).
+additive_tail(AST, AST) --> [].
+```
+
+The accumulator removes left recursion without moving parsing into JavaScript.
+A second DCG walks the AST in the other direction and emits only the parentheses
+needed to preserve its structure.  The example therefore exercises parsing,
+semantic actions, nonterminal-to-nonterminal state hand-off, generation,
+backtracking, `phrase/3` remainder handling, and AST-to-token-to-AST
+round-tripping.  The checked answers are in
+[`examples/output/dcg-expression-language.pl`](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/dcg-expression-language.pl).
+
+#### Deep sequence hand-off
+
+`library(iso_ext)` provides the common `...//0` helper, which describes an
+arbitrary number of input elements.  It is not part of ISO Part 3, but it is a
+useful interoperability and stress-test relation.  A compact hand-off test is:
+
+```text
+a --> ..., epsilon.
+epsilon --> [].
+```
+
+Here the remaining sequence is repeatedly passed from `...//0` to another
+nonterminal.  For a finite compact list, EyeProlog can scan the arbitrary
+sequence iteratively instead of consuming one ordinary solver depth level per
+list cell.  If the continuation is structurally proven to be a zero-width
+identity grammar such as `epsilon//0`, the hand-off can be continued without
+constructing a fresh general clause-resolution frame at every suffix.  The list
+spine is still traversed; this is a control/allocation optimization rather than
+an O(1) semantic shortcut.
+
+The optimization is deliberately narrow.  `phrase(..., Sequence, Rest)` still
+enumerates the valid remainders, open or non-compact inputs retain ordinary
+relational behavior, and grammars that can consume or constrain the remainder
+are not treated as identity continuations.  `time/1` can be used in normal mode
+to measure such runs; its inference counter records solver-level inferences and
+does not count every internal step of an optimized scanner.
+
 Part 3 leaves `\+//1` and standalone `->//2` implementation dependent.
 EyeProlog uses non-consuming negation (`\+ Body` tests from the current state)
 and threads the state produced by the condition into the then-grammar.
@@ -6067,14 +6123,16 @@ so side effects occur in Prolog execution order.
 
 ### The EyeProlog library
 
-EyeProlog exposes **126 library predicate indicators** in addition to the 129
-indicators in its isolated ISO profile. **87 are defined as ordinary Prolog
-clauses** in focused modules under `src/lib/`. The remaining 39
-are public wrappers around backtrackable host support: Prologue `call_nth/2` and
-`freeze/2`, plus the 37-predicate finite-domain `library(clpz)` kernel. The
-resulting normal EyeProlog language surface is therefore **255 public predicate
-indicators**. Internally, the runtime registry contains the 129 ISO definitions
-plus 23 private library adapters; public relations remain module source clauses.
+EyeProlog exposes **128 library predicate indicators** in addition to the 129
+indicators in its isolated ISO profile. **88 are defined entirely as ordinary
+Prolog clauses** in focused modules under `src/lib/`. The remaining public
+relations use small private host adapters where control, constraints, or host
+observability cannot be expressed by ordinary clauses alone; `time/1` is one
+such relation. The resulting normal EyeProlog language surface is therefore
+**257 public predicate indicators**. Most library relations remain module source
+clauses over private adapters. `time/1` is additionally registered directly in
+the normal EyeProlog runtime so Trealla-style timing works at the interactive
+top level without an import; it is absent from the strict ISO registry.
 
 The sources are `src/lib/aggregate.pl`, `src/lib/clpz.pl`, `src/lib/comparison.pl`,
 `src/lib/dates.pl`, `src/lib/iso_ext.pl`, `src/lib/lambda.pl`,
@@ -6110,7 +6168,7 @@ between solution branches.
 | `library(clpz)` | `#>/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`, `scalar_product/4`, `tuples_in/2`, `labeling/2`, `label/1`, `indomain/1`, `lex_chain/1`, `serialized/2`, `global_cardinality/2`, `global_cardinality/3`, `circuit/1`, `chain/2`, `element/3`, `zcompare/3`, `fd_var/1`, `fd_inf/2`, `fd_sup/2`, `fd_size/2`, `fd_dom/2` |
 | `library(comparison)` | `lt/2`, `gt/2`, `le/2`, `ge/2` |
 | `library(dates)` | `difference/3` |
-| `library(iso_ext)` | `call_nth/2`, `countall/2`, `forall/2`, `succ/2`, `cfor/3`, `findall/4`, `variant/2` |
+| `library(iso_ext)` | `call_nth/2`, `countall/2`, `forall/2`, `succ/2`, `cfor/3`, `findall/4`, `variant/2`, `time/1`, `.../2` |
 | `library(lambda)` | `^/3`, `^/4`, `^/5`, `^/6`, `^/7`, `^/8`, `^/9`, `^/10`, `\/1`, `\/2`, `\/3`, `\/4`, `\/5`, `\/6`, `\/7`, `\/8`, `+\/2`, `+\/3`, `+\/4`, `+\/5`, `+\/6`, `+\/7`, `+\/8`, `+\/9` |
 | `library(lists)` | `member/2`, `memberchk/2`, `select/3`, `append/2`, `append/3`, `last/2`, `same_length/2`, `nth0/3`, `nth0/4`, `nth1/3`, `nth1/4`, `reverse/2`, `length/2`, `maplist/2`, `maplist/3`, `maplist/4`, `maplist/5`, `maplist/6`, `maplist/7`, `maplist/8`, `foldl/4`, `foldl/5`, `foldl/6`, `sum_list/2`, `min_list/2`, `max_list/2`, `list_to_set/2`, `set_nth0/4`, `take/3`, `drop/3`, `slice/4` |
 | `library(primes)` | `smallest_divisor_from/3` |
@@ -6144,7 +6202,7 @@ The current interoperability profile recognizes these library roles:
 | Library | Role in the interoperability profile |
 | --- | --- |
 | `library(lists)` | Common list module. A conservative subset of its exports is in the shared predicate profile. |
-| `library(iso_ext)` | Common extension-module name. `call_nth/2` is currently its autoloaded cross-engine predicate. |
+| `library(iso_ext)` | Common extension-module name. `call_nth/2`, `time/1`, and the `...//0` arbitrary-sequence helper are conservatively autoloaded for cross-engine source. |
 | `library(lambda)` | Scryer-aligned higher-order notation. It is imported explicitly because loading it also installs the `+\` operator. |
 | `library(prologue)` | EyeProlog compatibility module, not a common interop library name. `between/3` is nevertheless autoloaded from it so portable source need not name this EyeProlog-specific provider. |
 
@@ -6168,9 +6226,14 @@ recovery headroom so finite-heap exhaustion remains a catchable
 `resource_error(memory)`.
 
 `library(iso_ext)` is a common interop module name, but only part of its
-EyeProlog API belongs to the shared profile. `call_nth/2` is mapped there to
-match Scryer's explicit import organization while also permitting portable
-unqualified source to autoload it. The interop exports of `library(lists)` and
+EyeProlog API belongs to the shared profile. `call_nth/2`, `time/1`, and
+`.../2` are mapped there. `time/1` measures each solution of a meta-call and
+prints elapsed time, EyeProlog inference count, and MLips in Trealla-style form,
+for example `% Time elapsed 0.832s, 65551 Inferences, 0.079 MLips`; `...//0`
+describes an arbitrary number of input elements. Together they let the
+Trealla/Scryer DCG hand-off benchmark run in EyeProlog without source changes
+(assuming the usual list library is already imported in an interactive
+session). The interop exports of `library(lists)` and
 `library(iso_ext)` are kept disjoint, so both modules can be imported together
 without an accidental collision. `library(prologue)` remains a compatibility
 umbrella and overlaps them; use selective imports when legacy code combines it
@@ -6206,14 +6269,19 @@ uses its ISO `copy_term/2` implementation for the fresh-copy step and does not
 require a separate `copy_term_nat/2` predicate.
 
 Autoloading is a convenience layered on top of the interoperability profile; it
-is not a general search through all EyeProlog libraries. During normal
-execution, an otherwise undefined **unqualified** predicate may be autoloaded
-only when the interop table assigns it one canonical provider. For example:
+is not a general search through all EyeProlog libraries. When a source program
+or an explicit CLI/API goal is built, an otherwise undefined **unqualified**
+predicate may be autoloaded only when the interop table assigns it one canonical
+provider. The interactive top level keeps ordinary library imports explicit;
+`time/1` is available there because it is also a normal EyeProlog runtime
+extension. For example, the canonical build-time providers are:
 
 | Predicate | Canonical autoload provider |
 | --- | --- |
 | `member/2` | `library(lists)` |
 | `call_nth/2` | `library(iso_ext)` |
+| `time/1` | `library(iso_ext)` |
+| `.../2` | `library(iso_ext)` |
 | `between/3` | `library(prologue)` |
 
 Predicates outside that table require an explicit import even when EyeProlog
@@ -6255,9 +6323,9 @@ into later branches. Trealla's larger library also contains facilities such as
 automata, cumulative and two-dimensional scheduling constraints, and
 unbounded-domain propagation that EyeProlog does not currently export.
 
-Beyond its interop entry for `call_nth/2`, `library(iso_ext)` also exports
-EyeProlog's extension relations `countall/2`, `forall/2`, `succ/2`, `cfor/3`,
-`findall/4`, and `variant/2`. `forall/2` checks an action for every solution of a
+Alongside its interop entries `call_nth/2`, `time/1`, and `.../2`,
+`library(iso_ext)` also exports EyeProlog's extension relations `countall/2`,
+`forall/2`, `succ/2`, `cfor/3`, `findall/4`, and `variant/2`. `forall/2` checks an action for every solution of a
 condition; `cfor/3` enumerates an inclusive evaluated integer range; `succ/2`
 relates adjacent nonnegative integers; `findall/4` collects into a difference
 list; and `variant/2` recognizes terms equal up to variable renaming.
@@ -6883,7 +6951,7 @@ Review questions:
 </figure>
 
 The [examples directory](https://github.com/eyereasoner/eyeprolog/tree/main/examples/) is the book's executable companion. The
-top-level directory contains **211 self-contained runnable programs**. Every
+top-level directory contains **212 self-contained runnable programs**. Every
 source program has an exact answer file under
 [examples/output](https://github.com/eyereasoner/eyeprolog/tree/main/examples/output/), and **61 selected programs** have a checked
 explanation under [examples/proof](https://github.com/eyereasoner/eyeprolog/tree/main/examples/proof/). The thematic tables below link every top-level program and open the program
@@ -6941,6 +7009,7 @@ mode at a time.
 | [Atomic conversion](https://github.com/eyereasoner/eyeprolog/blob/main/examples/iso-atomic-conversion.pl) | Atom splitting, character atoms, Unicode codes, and numeric parsing. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/iso-atomic-conversion.pl) |
 | [Control and errors](https://github.com/eyereasoner/eyeprolog/blob/main/examples/iso-control-and-errors.pl) | `call/1`, `once/1`, cut, if-then-else, `throw/1`, and `catch/3`. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/iso-control-and-errors.pl) |
 | [DCG command parser](https://github.com/eyereasoner/eyeprolog/blob/main/examples/dcg-command-parser.pl) | A Part 3 grammar parses token lists into application terms, generates tokens, preserves a remainder, and rejects malformed input. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/dcg-command-parser.pl) |
+| [DCG expression language](https://github.com/eyereasoner/eyeprolog/blob/main/examples/dcg-expression-language.pl) | A precedence-aware bidirectional grammar builds arithmetic ASTs, evaluates variable expressions, regenerates minimally parenthesized tokens, round-trips syntax, and preserves a remainder. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/dcg-expression-language.pl) |
 | [Dynamic database](https://github.com/eyereasoner/eyeprolog/blob/main/examples/iso-dynamic-database.pl) | Initialization and ordered updates to a declared dynamic procedure. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/iso-dynamic-database.pl) · [proof](https://github.com/eyereasoner/eyeprolog/blob/main/examples/proof/iso-dynamic-database.pl) |
 | [Grouped solutions](https://github.com/eyereasoner/eyeprolog/blob/main/examples/iso-grouped-solutions.pl) | `findall/3`, `bagof/3`, `setof/3`, existential qualification, and `clause/2`. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/iso-grouped-solutions.pl) |
 | [Integer arithmetic](https://github.com/eyereasoner/eyeprolog/blob/main/examples/iso-integer-arithmetic.pl) | Integer quotient/remainder choices plus bit operations. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/iso-integer-arithmetic.pl) |
@@ -7285,7 +7354,7 @@ hand.
 
 #### Running and extending the corpus
 
-Run all 211 normal answer goldens and the 61 selected proof goldens with:
+Run all 212 normal answer goldens and the 61 selected proof goldens with:
 
 ```sh
 npm run test:examples
@@ -7349,7 +7418,7 @@ The complete suite must pass before release. The file-based conformance corpus
 contains 791 cases, including 386 focused ISO
 cases derived from the success, failure, mode, and error behavior in
 ISO/IEC 13211-1 clauses 7 and 8, Part 2 modules, and Part 3 grammar rules.
-Separate exact-output suites check 211 normal
+Separate exact-output suites check 212 normal
 examples and 61 proof examples; all extracted book programs are parsed and
 their declared goals are executed. The eight-case
 playground contract suite imports the production worker, sends real reasoning

package/why-eyeprolog.md

@@ -60,6 +60,14 @@ positive Datalog closures with a shared relation-wide table, but the admission
 heuristics are implementation details. Programs should rely on the documented
 semantics and finiteness conditions, not on a particular internal threshold.
 
+DCGs follow the same rule.  Their meaning remains the ISO Part 3 difference-list
+model, while finite sequence scans and proven zero-width hand-offs may use
+lighter internal control paths so deep grammars do not pay one general solver
+frame per token.  Relational remainder-producing modes are preserved.  The
+checked `examples/dcg-expression-language.pl` program shows the declarative side
+of that design: one grammar builds precedence-aware syntax trees and another
+generates minimally parenthesized token sequences back from them.
+
 ## Why proofs?
 
 An answer says that a goal succeeded. A proof records one successful route