eyeprolog 1.3.84 → 1.3.86

package/package.json

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

package/src/cleanup.js

@@ -237,10 +237,11 @@ function cleanupProtectedIterator(solver, protectedGoal, cleanup, initialEnv) {
   let unwindToSetupBindings = false;
 
   const performCleanup = () => {
-    if (cleaned) return;
+    if (cleaned) return cleanupEnv;
     // Mark first so a throwing Cleanup is still considered executed exactly once.
     cleaned = true;
-    runCleanupOnce(solver, cleanup, cleanupEnv);
+    cleanupEnv = runCleanupOnce(solver, cleanup, cleanupEnv);
+    return cleanupEnv;
   };
 
   const iterator = (function* protectedWithCleanup() {
@@ -266,7 +267,7 @@ function cleanupProtectedIterator(solver, protectedGoal, cleanup, initialEnv) {
           performCleanup();
         }
 
-        yield result.value;
+        yield pending ? result.value : cleanupEnv;
         if (!pending) return;
       }
     } catch (error) {
@@ -321,8 +322,9 @@ function runCleanupOnce(solver, cleanup, env) {
       solver.absorbStatsFrom(child);
     }
   }
-  // Cleanup is semidet only as a control operation: failure is ignored, and
-  // bindings made solely by Cleanup are intentionally not added to an answer
-  // already produced by Goal.
-  return !result.done;
+  // Cleanup failure is ignored. When Cleanup runs before a deterministic
+  // protected answer is yielded, however, its substitutions are part of that
+  // answer; callers that prune a pending answer have already observed it and
+  // therefore cannot receive later Cleanup substitutions.
+  return result.done ? env : result.value;
 }

package/src/iso.js

@@ -137,8 +137,10 @@ export const isoBuiltins = {
     registry.add('number_chars', 2, numberCharsBuiltin, { deterministic: true });
     registry.add('number_codes', 2, numberCodesBuiltin, { deterministic: true });
 
-    registry.add('call', 1, callBuiltin);
-    for (let arity = 2; arity <= 8; arity++) registry.add('call', arity, callClosureBuiltin);
+    registry.add('call', 1, callBuiltin, { expandGoal: expandCallGoal });
+    for (let arity = 2; arity <= 8; arity++) {
+      registry.add('call', arity, callClosureBuiltin, { expandGoal: expandCallClosureGoal });
+    }
     registry.add('catch', 3, catchBuiltin);
     registry.add('throw', 1, throwBuiltin, { deterministic: true });
     registry.add('\\+', 1, negationBuiltin, { deterministic: true });
@@ -166,7 +168,7 @@ export const eyePrologLibraryBuiltins = {
   register(registry) {
     registry.add('eyeprolog__call_nth', 2, callNthBuiltin, { eyePrologLibrary: true });
     registry.add('eyeprolog__call_residue_vars', 2, callResidueVarsBuiltin, { eyePrologLibrary: true });
-    registry.add('eyeprolog__countall', 2, countAllBuiltin, { eyePrologLibrary: true });
+    registry.add('eyeprolog__countall', 2, countAllBuiltin, { deterministic: true, eyePrologLibrary: true });
     registry.add('eyeprolog__freeze', 2, freezeBuiltin, { eyePrologLibrary: true });
     registry.add('dif', 2, difBuiltin, { deterministic: true, eyePrologLibrary: true });
     registry.add('time', 1, timeBuiltin, { eyePrologLibrary: true });
@@ -712,27 +714,43 @@ function assertBuiltin(atStart) {
   };
 }
 
-function* retractBuiltin({ solver, goal, env }) {
+function retractBuiltin(context) {
+  const state = { pending: true };
+  const iterator = retractSolutions(context, state);
+  iterator.hasPendingAlternatives = () => state.pending;
+  return iterator;
+}
+
+function* retractSolutions({ solver, goal, env }, state) {
   const parts = clauseParts(goal.args[0], env);
   requireClauseHead(parts.head);
   const group = solver.program.findGroup(parts.head.name, parts.head.arity, parts.head.module ?? goal.module ?? 'user');
   if (isProcessorStaticProcedure(solver, parts.head) || (group && !group.dynamic)) {
     throw new PrologError('permission_error(modify, static_procedure)', procedureIndicator(parts.head));
   }
-  if (!group) return;
+  if (!group) {
+    state.pending = false;
+    return;
+  }
   // ISO logical update view: this call keeps the clauses that were visible
   // when it began. A later retract/1 may erase one of those clauses from the
   // live procedure, but must not invalidate this call's pending alternatives.
-  const candidates = [...group.clauses];
-  for (const clause of candidates) {
+  const matches = [];
+  for (const clause of [...group.clauses]) {
     const copied = freshCopy(compound('$clause', [clause.head, clauseBodyTerm(clause.body)]), new Env());
     const next = env.clone();
     if (!unify(parts.head, copied.args[0], next)) continue;
     if (parts.rule && !unify(parts.body, copied.args[1], next)) continue;
     if (!parts.rule && !(copied.args[1].type === ATOM && copied.args[1].name === 'true')) continue;
+    matches.push({ clause, next });
+  }
+  for (let index = 0; index < matches.length; index++) {
+    const { clause, next } = matches[index];
     solver.program.removeDynamicClause(group, clause);
+    state.pending = index + 1 < matches.length;
     yield next;
   }
+  state.pending = false;
 }
 
 function* retractAllBuiltin({ solver, goal, env }) {
@@ -1555,6 +1573,24 @@ function scopeReadTerm(term) {
 
 function parseReadTermText(text, solver) {
   const converted = convertedTermText(text, solver);
+  // A standalone number needs no general term parser or operator tables.
+  // Reuse the same bounded numeric scanner as number_chars/2 so stream reads
+  // and number conversion agree on every accepted numeric token. The stream
+  // scanner has already established that the final full stop is a candidate
+  // terminator; trim only ISO layout immediately before that terminator.
+  const numericText = converted.slice(0, -1).replace(/[\u0009-\u000d\u0020]+$/, '');
+  let numericTerm;
+  try {
+    numericTerm = parseIsoNumber(numericText);
+  } catch (error) {
+    // parseIsoNumber/1 exposes Prolog errors to number_chars/2. The stream
+    // reader's candidate loop instead recognizes parser representation errors
+    // and must not reinterpret overflow as a later syntax error.
+    if (error instanceof PrologError) throw new NumberRepresentationError(error.formal);
+    throw error;
+  }
+  if (numericTerm != null) return numericTerm;
+
   const operatorState = createParserOperatorState(solver.program.operators.values(), false);
   return parseTermText(converted, {
     operatorState,
@@ -1720,6 +1756,15 @@ function writeOptionBoolean(value, env, option) {
   return value.name === 'true';
 }
 
+function writeOptionSpacing(value, env, option) {
+  value = deref(value, env);
+  if (value.type === VAR) throw new PrologError('instantiation_error');
+  if (value.type !== ATOM || !['minimal', 'standard'].includes(value.name)) {
+    throw new PrologError('domain_error(write_option)', copyResolved(option, env));
+  }
+  return value.name;
+}
+
 function writeVariableNames(value, env, option) {
   value = deref(value, env);
   if (value.type === VAR) throw new PrologError('instantiation_error');
@@ -1760,6 +1805,8 @@ function termWriteOptionsFromItems(options, env, mode = 'write_term', solver = n
     else if (option.name === 'variable_names') result.variableNames = writeVariableNames(option.args[0], env, option);
     else if (option.name === 'double_quotes' && !solver?.isoStrict) {
       result.doubleQuotes = writeOptionBoolean(option.args[0], env, option);
+    } else if (option.name === 'spacing' && !solver?.isoStrict) {
+      result.minimalOperatorSpacing = writeOptionSpacing(option.args[0], env, option) === 'minimal';
     } else {
       throw new PrologError('domain_error(write_option)', copyResolved(option, env));
     }
@@ -2384,6 +2431,11 @@ function callable(term, env) {
   validateControlCallable(term, term, env);
   return term;
 }
+
+function withPendingState(iterator, state) {
+  iterator.hasPendingAlternatives = () => state.pending;
+  return iterator;
+}
 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
@@ -2409,9 +2461,14 @@ function validateControlCallable(term, culprit, env) {
     }
   }
 }
-function* callBuiltin({ solver, goal, env }) {
+function expandCallGoal({ goal, env }) {
   const invoked = callable(goal.args[0], env);
   if (invoked.module == null) invoked.module = goal.module ?? 'user';
+  return invoked;
+}
+function* callBuiltin(context) {
+  const { solver, env } = context;
+  const invoked = expandCallGoal(context);
   const child = solver.cloneForInnerGoal();
   try {
     yield* child.solve([invoked], env, 0);
@@ -2419,7 +2476,7 @@ function* callBuiltin({ solver, goal, env }) {
     solver.absorbStatsFrom(child);
   }
 }
-function* callClosureBuiltin({ solver, goal, env }) {
+function expandCallClosureGoal({ goal, env }) {
   const closure = callable(goal.args[0], env);
   const existing = closure.type === COMPOUND ? closure.args : [];
   const extra = goal.args.slice(1);
@@ -2428,6 +2485,11 @@ function* callClosureBuiltin({ solver, goal, env }) {
   }
   const invoked = compound(closure.name, [...existing, ...extra]);
   invoked.module = closure.module ?? goal.module ?? 'user';
+  return invoked;
+}
+function* callClosureBuiltin(context) {
+  const { solver, env } = context;
+  const invoked = expandCallClosureGoal(context);
   const child = solver.cloneForInnerGoal();
   try {
     yield* child.solve([invoked], env, 0);
@@ -2480,7 +2542,12 @@ function writeElapsedTime(solver, startedAt, inferences) {
   );
 }
 
-function* timeBuiltin({ solver, goal, env }) {
+function timeBuiltin(context) {
+  const state = { pending: true };
+  return withPendingState(timeSolutions(context, state), state);
+}
+
+function* timeSolutions({ solver, goal, env }, state) {
   const invoked = callable(goal.args[0], env);
   const child = solver.cloneForInnerGoal();
   let startedAt = monotonicMilliseconds();
@@ -2490,12 +2557,15 @@ function* timeBuiltin({ solver, goal, env }) {
     for (const answerEnv of child.solve([invoked], env, 0)) {
       writeElapsedTime(solver, startedAt, child.inferenceObservation.value - startedInferences);
       yieldedAny = true;
+      state.pending = child.hasPendingAlternatives();
       yield answerEnv;
+      if (!state.pending) return;
       // 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;
     }
+    state.pending = false;
     // A call that fails without producing an answer still reports the work.
     if (!yieldedAny) writeElapsedTime(solver, startedAt, child.inferenceObservation.value - startedInferences);
   } finally {
@@ -2503,10 +2573,18 @@ function* timeBuiltin({ solver, goal, env }) {
   }
 }
 
-function* callNthBuiltin({ solver, goal, env }) {
+function callNthBuiltin(context) {
+  const state = { pending: true };
+  return withPendingState(callNthSolutions(context, state), state);
+}
+
+function* callNthSolutions({ solver, goal, env }, state) {
   const requestedTerm = deref(goal.args[1], env);
   // Zero is the one Nth value that fails before Goal is inspected.
-  if (requestedTerm.type === NUMBER && isDecimalInteger(requestedTerm.name) && BigInt(requestedTerm.name) === 0n) return;
+  if (requestedTerm.type === NUMBER && isDecimalInteger(requestedTerm.name) && BigInt(requestedTerm.name) === 0n) {
+    state.pending = false;
+    return;
+  }
 
   const invoked = callable(goal.args[0], env);
   let requested = null;
@@ -2525,9 +2603,13 @@ function* callNthBuiltin({ solver, goal, env }) {
       nth++;
       if (requested != null && nth < requested) continue;
       const next = answerEnv.clone();
-      if (unify(goal.args[1], numberTerm(nth.toString()), next)) yield next;
-      if (requested != null) return;
+      if (unify(goal.args[1], numberTerm(nth.toString()), next)) {
+        state.pending = requested == null && child.hasPendingAlternatives();
+        yield next;
+        if (requested != null || !state.pending) return;
+      }
     }
+    state.pending = false;
   } finally {
     solver.absorbStatsFrom(child);
   }
@@ -2619,12 +2701,22 @@ function callResidueVarsBuiltin({ solver, goal, env }) {
   return iterator;
 }
 
-function* freezeBuiltin({ solver, goal, env }) {
+function freezeBuiltin(context) {
+  const state = { pending: true };
+  return withPendingState(freezeSolutions(context, state), state);
+}
+
+function* freezeSolutions({ solver, goal, env }, state) {
   const watched = deref(goal.args[0], env);
   if (watched.type !== VAR) {
     const child = solver.cloneForInnerGoal();
     try {
-      yield* child.solve([callable(goal.args[1], env)], env, 0);
+      for (const answerEnv of child.solve([callable(goal.args[1], env)], env, 0)) {
+        state.pending = child.hasPendingAlternatives();
+        yield answerEnv;
+        if (!state.pending) return;
+      }
+      state.pending = false;
     } finally {
       solver.absorbStatsFrom(child);
     }
@@ -2632,10 +2724,16 @@ function* freezeBuiltin({ solver, goal, env }) {
   }
   const next = env.clone();
   next.delay(watched.name, goal.args[1], goal.module ?? 'user');
+  state.pending = false;
   yield next;
 }
 
-function* phraseBuiltin({ solver, goal, env }) {
+function phraseBuiltin(context) {
+  const state = { pending: true };
+  return withPendingState(phraseSolutions(context, state), state);
+}
+
+function* phraseSolutions({ solver, goal, env }, state) {
   const grammarBody0 = deref(goal.args[0], env);
   if (grammarBody0.type === VAR) throw new PrologError('instantiation_error');
   if (grammarBody0.type !== ATOM && grammarBody0.type !== COMPOUND) {
@@ -2692,7 +2790,12 @@ function* phraseBuiltin({ solver, goal, env }) {
     skipListTailTabling: !repeatedInvocation,
   });
   try {
-    yield* child.solve(finish == null ? [expanded] : [expanded, finish], env, 0);
+    for (const answerEnv of child.solve(finish == null ? [expanded] : [expanded, finish], env, 0)) {
+      state.pending = child.hasPendingAlternatives();
+      yield answerEnv;
+      if (!state.pending) return;
+    }
+    state.pending = false;
   } finally {
     solver.absorbStatsFrom(child);
     solver.trimInnerTableScope('phrase');
@@ -2752,7 +2855,12 @@ function prologErrorBall(error) {
   if (hasDefaultGroundErrorShape(error) || termIsGround(term)) return term;
   return freshCopy(term, new Env());
 }
-function* catchBuiltin({ solver, goal, env }) {
+function catchBuiltin(context) {
+  const state = { pending: true };
+  return withPendingState(catchSolutions(context, state), state);
+}
+
+function* catchSolutions({ solver, goal, env }, state) {
   let child = null;
   try {
     // Corrigendum 2 removed catch/3's own callability errors so that errors
@@ -2769,12 +2877,19 @@ function* catchBuiltin({ solver, goal, env }) {
       if (result.done) solver.stats.deterministic_builtin_failures++;
       else {
         solver.stats.deterministic_builtin_successes++;
+        state.pending = false;
         yield result.value;
       }
+      state.pending = false;
       return;
     }
     child = solver.cloneForInnerGoal();
-    yield* child.solve([invoked], env.clone(), 0);
+    for (const answerEnv of child.solve([invoked], env.clone(), 0)) {
+      state.pending = child.hasPendingAlternatives();
+      yield answerEnv;
+      if (!state.pending) return;
+    }
+    state.pending = false;
   } catch (error) {
     const ball = error instanceof ThrownTerm
       ? error.term
@@ -2785,12 +2900,18 @@ function* catchBuiltin({ solver, goal, env }) {
     const recovered = env.clone();
     if (!unify(goal.args[1], ball, recovered)) throw error;
     const recovery = callable(goal.args[2], recovered);
-    if (recovery.type === ATOM && (recovery.name === 'false' || recovery.name === 'fail')) return;
+    if (recovery.type === ATOM && (recovery.name === 'false' || recovery.name === 'fail')) {
+      state.pending = false;
+      return;
+    }
     if (recovery.type === ATOM && recovery.name === 'true') {
+      state.pending = false;
       yield recovered;
       return;
     }
-    yield* solver.solve([recovery], recovered, 0);
+    yield* solveControlBranch(solver, recovery, recovered,
+      (pending) => { state.pending = pending; });
+    state.pending = false;
   } finally {
     if (child != null) solver.absorbStatsFrom(child);
   }
@@ -2888,11 +3009,19 @@ function* disjunctionSolutions({ solver, goal, env }, state) {
     (pending) => { state.pending = pending; });
   state.pending = false;
 }
-function* ifThenBuiltin({ solver, goal, env }) {
+function ifThenBuiltin(context) {
+  const state = { pending: true };
+  return withPendingState(ifThenSolutions(context, state), state);
+}
+
+function* ifThenSolutions({ solver, goal, env }, state) {
   for (const conditionEnv of solver.cloneForInnerGoal(1).solve([callable(goal.args[0], env)], env.clone(), 0)) {
-    yield* solveControlBranch(solver, goal.args[1], conditionEnv);
+    yield* solveControlBranch(solver, goal.args[1], conditionEnv,
+      (pending) => { state.pending = pending; });
+    state.pending = false;
     return;
   }
+  state.pending = false;
 }
 
 export { arithmeticValueTerm, evaluateArithmetic, compareArithmeticValues } from './iso-arithmetic.js';
@@ -2911,6 +3040,7 @@ export class BuiltinRegistry {
       handler,
       deterministic: options.deterministic ?? false,
       deterministicWhen: options.deterministicWhen ?? null,
+      expandGoal: options.expandGoal ?? null,
       ready: options.ready ?? null,
       fallbackWhenNotReady: options.fallbackWhenNotReady ?? false,
       shouldUse: options.shouldUse ?? null,

package/src/scryer-compat.js

@@ -207,9 +207,9 @@ function* termCharsBuiltin({ solver, goal, env }) {
 
 export const scryerCompatibilityBuiltins = {
   register(registry) {
-    registry.add('eyeprolog__bb_get', 2, bbGetBuiltin, { eyePrologLibrary: true });
+    registry.add('eyeprolog__bb_get', 2, bbGetBuiltin, { deterministic: true, eyePrologLibrary: true });
     registry.add('eyeprolog__bb_b_put', 2, bbPutBuiltin, { deterministic: true, eyePrologLibrary: true });
-    registry.add('eyeprolog__bb_global_get', 2, bbGlobalGetBuiltin, { eyePrologLibrary: true });
+    registry.add('eyeprolog__bb_global_get', 2, bbGlobalGetBuiltin, { deterministic: true, eyePrologLibrary: true });
     registry.add('eyeprolog__bb_global_put', 2, bbGlobalPutBuiltin, { deterministic: true, eyePrologLibrary: true });
     registry.add('eyeprolog__char_type', 2, charTypeBuiltin, { eyePrologLibrary: true });
     registry.add('eyeprolog__current_time', 1, currentTimeBuiltin, { deterministic: true, eyePrologLibrary: true });

package/src/solver.js

@@ -614,7 +614,21 @@ export class Solver {
 
         const def = callable ? this.registry.get(goal.name, goal.arity) : null;
         this.active = active;
-        if (def && builtinIsReadyOrAuthoritative(def, this, goal, env)) {
+        const builtinReady = def && builtinIsReadyOrAuthoritative(def, this, goal, env);
+        if (builtinReady && typeof def.expandGoal === 'function') {
+          // Meta-calls execute in this continuation instead of hiding their
+          // search behind a host-generator frame. Their real clause, control,
+          // and builtin frames therefore determine whether another answer is
+          // pending exactly as they do for a direct call. A fresh active marker
+          // keeps cut opaque at the call/N boundary.
+          const expanded = def.expandGoal({ solver: this, goal, env });
+          const invocation = { goal, env };
+          active = [...active, invocation];
+          goals = [expanded, { kind: 'releaseActive' }, ...rest];
+          depth++;
+          continue;
+        }
+        if (builtinReady) {
           const deterministic = def.deterministic ||
             def.deterministicWhen?.({ solver: this, goal, env }) === true;
           const iterator = def.handler({ solver: this, goal, env });
@@ -1414,10 +1428,7 @@ function bundledBetweenIterator(solver, group, goal, env) {
   // the generated value in the caller repeatedly revisits all earlier frames.
   // Enumerate the canonical bundled relation directly while leaving user
   // definitions and non-EyeProlog registries on the ordinary Prolog path.
-  const state = { pending: true };
-  const iterator = bundledBetweenSolutions(solver, goal, env, state);
-  iterator.hasPendingAlternatives = () => state.pending;
-  return iterator;
+  return bundledBetweenSolutions(solver, goal, env);
 }
 
 function requireBetweenInteger(term, env) {
@@ -1429,7 +1440,7 @@ function requireBetweenInteger(term, env) {
   return BigInt(value.name);
 }
 
-function* bundledBetweenSolutions(solver, goal, env, state) {
+function* bundledBetweenSolutions(solver, goal, env) {
   const lower = requireBetweenInteger(goal.args[0], env);
   const upper = requireBetweenInteger(goal.args[1], env);
   const requested = deref(goal.args[2], env);
@@ -1439,23 +1450,15 @@ function* bundledBetweenSolutions(solver, goal, env, state) {
       throw new PrologError('type_error(integer)', requested);
     }
     const value = BigInt(requested.name);
-    if (value >= lower && value <= upper) {
-      state.pending = false;
-      yield env;
-    }
-    state.pending = false;
+    if (value >= lower && value <= upper) yield env;
     return;
   }
 
   for (let value = lower; value <= upper; value++) {
     const next = env.clone();
     solver.stats.unify_calls++;
-    if (unify(goal.args[2], numberTerm(value), next)) {
-      state.pending = value < upper;
-      yield next;
-    }
+    if (unify(goal.args[2], numberTerm(value), next)) yield next;
   }
-  state.pending = false;
 }
 
 function bundledMemberIterator(solver, group, goal, env) {
@@ -1472,33 +1475,18 @@ function bundledMemberIterator(solver, group, goal, env) {
   let cursor = deref(goal.args[1], env);
   while (isCons(cursor)) cursor = deref(cursor.args[1], env);
   if (!isEmptyList(cursor)) return null;
-  const state = { pending: true };
-  const iterator = bundledMemberSolutions(solver, goal, env, state);
-  iterator.hasPendingAlternatives = () => state.pending;
-  return iterator;
+  return bundledMemberSolutions(solver, goal, env);
 }
 
-function* bundledMemberSolutions(solver, goal, env, state) {
+function* bundledMemberSolutions(solver, goal, env) {
   let cursor = deref(goal.args[1], env);
   while (isCons(cursor)) {
     const item = cursor.args[0];
     cursor = deref(cursor.args[1], env);
     const next = env.clone();
     solver.stats.unify_calls++;
-    if (unify(goal.args[0], item, next)) {
-      state.pending = bundledMemberMayMatch(goal.args[0], cursor, env);
-      yield next;
-    }
+    if (unify(goal.args[0], item, next)) yield next;
   }
-  state.pending = false;
-}
-
-function bundledMemberMayMatch(target, cursor, env) {
-  while (isCons(cursor)) {
-    if (!goalHeadTermsCannotMatch(target, cursor.args[0], env)) return true;
-    cursor = deref(cursor.args[1], env);
-  }
-  return false;
 }
 
 function bundledEllipsisPlan(solver, group, goal, rest, env) {
@@ -2187,13 +2175,7 @@ function pushStreamingScalarFactRun(stack, solver, runGoals, groups, rest, env,
   const iterator = scalarFactRunSolutions(solver, runGoals, groups, env, depth, active);
   const first = iterator.next();
   if (first.done) return;
-  stack.push({
-    kind: 'resumeBuiltin',
-    iterator,
-    goals: rest,
-    depth: depth + runGoals.length,
-    active,
-  });
+  pushResumeBuiltinFrame(stack, iterator, rest, depth + runGoals.length, active);
   stack.push({
     kind: 'goals',
     goals: rest,
@@ -2831,10 +2813,64 @@ function builtinIsReadyOrAuthoritative(def, solver, goal, env) {
 
 function iteratorMayHavePendingAlternatives(iterator) {
   const predicate = iterator?.hasPendingAlternatives;
-  return typeof predicate !== 'function' || predicate.call(iterator) !== false;
+  return typeof predicate === 'function' && predicate.call(iterator) !== false;
+}
+
+function lookaheadChoiceIterator(iterator) {
+  let buffered = null;
+  let bufferedReady = false;
+  let closed = false;
+
+  const fill = () => {
+    if (closed || bufferedReady) return;
+    buffered = iterator.next();
+    bufferedReady = true;
+    if (buffered.done) closed = true;
+  };
+
+  return {
+    next() {
+      fill();
+      if (buffered?.done !== false) return buffered ?? { done: true, value: undefined };
+      const result = buffered;
+      buffered = null;
+      bufferedReady = false;
+      // Ordinary relational iterators are advanced by one answer so their
+      // exhausted state is known before this answer reaches the caller.
+      fill();
+      return result;
+    },
+    return(value) {
+      if (!closed) iterator.return?.();
+      closed = true;
+      buffered = { done: true, value };
+      bufferedReady = true;
+      return buffered;
+    },
+    throw(error) {
+      closed = true;
+      if (typeof iterator.throw === 'function') return iterator.throw(error);
+      throw error;
+    },
+    prepareClose(reason) {
+      iterator.prepareClose?.(reason);
+    },
+    hasPendingAlternatives() {
+      fill();
+      return buffered?.done === false;
+    },
+    [Symbol.iterator]() { return this; },
+  };
+}
+
+function choicepointAwareIterator(iterator) {
+  return typeof iterator?.hasPendingAlternatives === 'function'
+    ? iterator
+    : lookaheadChoiceIterator(iterator);
 }
 
 function pushResumeBuiltinFrame(stack, iterator, goals, depth, active) {
+  iterator = choicepointAwareIterator(iterator);
   if (!iteratorMayHavePendingAlternatives(iterator)) {
     // Finish the suspended generator now so its finally blocks release child
     // solvers, aggregate statistics, and perform predicate-local cleanup.

package/test/conformance/ISO-COMPLIANCE.md

@@ -97,8 +97,8 @@ required permission error. `read_term/3`, `write_term/3`, `op/3`, and
 EyeProlog's chosen simultaneous-error behavior stable. Section 7.12 makes that
 choice implementation dependent when several error conditions hold at once. Strict `write_term/2-3` accepts only
 the Part 1 plus Corrigendum 3 option surface; the normal-profile
-`double_quotes/1` write option remains an explicitly documented EyeProlog
-extension.
+`double_quotes/1` and `spacing/1` write options remain explicitly documented
+implementation-specific EyeProlog extensions.
 
 
 The preparation, stream, conversion, sorting, and arithmetic audit expands the coverage into Prolog-text,

package/test/conformance/ISO-IMPLEMENTATION-DEFINED.md

@@ -124,7 +124,7 @@ families; `--iso-strict` is intended to remove their Part 1 interpretation.
 | 5.5.9 Built-in predicates | EyeProlog libraries, CLP(Z), statistics, Part 3 `phrase/2-3`, and interop autoloaded predicates | Strict registry contains only the Part 1 + Corrigenda core registry. |
 | 5.5.10 Evaluable functors | Normal mode additionally accepts the EyeProlog evaluable atom `e`; the remaining arithmetic functors accepted by strict mode are the Part 1 + Corrigenda set. | Strict mode rejects `e/0` as non-evaluable and retains the Corrigendum arithmetic additions. **covered** — strict extension-boundary regression plus `src/iso-arithmetic.js`. |
 | 5.5.11 Reserved atoms | None | None. |
-| Cor.3 5.5.12 Options | Extra library/host options may exist outside core option lists | Normal mode additionally accepts the EyeProlog `write_term/2-3` option `double_quotes(true|false)`. Strict core excludes that extension and accepts only the Part 1 plus Corrigendum 3 write-option surface; unknown extension options raise `domain_error(write_option,...)`. |
+| Cor.3 5.5.12 Options | Extra library/host options may exist outside core option lists | Normal mode additionally accepts the EyeProlog `write_term/2-3` options `double_quotes(true|false)` and `spacing(minimal|standard)`. `minimal` emits only lexically required separators; `standard` adds conventional layout around operators. Strict core excludes these implementation-specific extensions and accepts only the Part 1 plus Corrigendum 3 write-option surface; unknown extension options raise `domain_error(write_option,...)`. |
 
 Normal mode provides documented module and DCG compatibility profiles whose
 features overlap standardized Part 2 and Part 3 facilities. They are extensions

package/test/run-cleanup.mjs

@@ -89,6 +89,18 @@ export function runCleanup(reporter) {
     assertEqual(result.stderr, '', 'stderr');
   });
 
+  reporter.test('setup_call_cleanup/3 exposes deterministic Cleanup substitutions (issue #77)', () => {
+    const result = runRepl(
+      'setup_call_cleanup(true,A=1,throw(called(A))).\n' +
+      'setup_call_cleanup(true,A=1,B=1).\n' +
+      'halt.\n',
+    );
+    assertEqual(result.status, 0, 'exit status');
+    assertIncludes(result.stdout, 'throw(called(1)).', 'Cleanup sees Goal substitutions');
+    assertIncludes(result.stdout, 'A = 1, B = 1.', 'answer includes Cleanup substitutions');
+    assertEqual(result.stderr, '', 'stderr');
+  });
+
   reporter.test('setup_call_cleanup/3 does not install cleanup when Setup fails', () => {
     const result = runRepl('setup_call_cleanup(fail,true,write(should_not_run)).\nhalt.\n');
     assertEqual(result.status, 0, 'status');

package/test/run-iso-strict.mjs

@@ -283,8 +283,16 @@ export function runIsoStrict(reporter = new TestReporter()) {
     }));
     equal(strictError.formal, 'domain_error(write_option)', 'strict extension rejection');
 
+    const strictSpacingError = capture(() => run('', {
+      isoStrict: true,
+      goal: 'write_term(1+1,[spacing(minimal)])',
+    }));
+    equal(strictSpacingError.formal, 'domain_error(write_option)', 'strict spacing extension rejection');
+
     const normal = run('', { goal: 'write_term("ab",[double_quotes(true)])' });
     includes(normal.stdout, '"ab"', 'normal-profile extension remains available');
+    includes(run('', { goal: 'write_term(1+1,[spacing(standard)])' }).stdout,
+      '1 + 1', 'normal-profile spacing extension remains available');
   });
 
   reporter.test('follows Corrigendum 3 variable metadata traversal and write naming', () => {

package/test/run-regression.mjs

@@ -1032,6 +1032,108 @@ c4 ?- call((!;1)).
         }
       },
     },
+    {
+      name: 'read/2 and number_chars/2 agree on bounded numeric syntax (issue #29)',
+      run: () => {
+        const registry = createDefaultRegistry();
+        const numberChars = registry.get('number_chars', 2).handler;
+        const read = registry.get('read', 2).handler;
+        const solver = new Solver(Program.parse(''), { registry, ioOptions: { input: '' } });
+        const stream = solver.io.resolve(0);
+        const streamTerm = compound('$stream', [numberTerm('0')]);
+        const alphabet = ['0', '1', '2', '7', '8', '9', 'a', 'f', 'x', 'e', 'E', '+', '-', '.', "'", '\\', ' '];
+        let checked = 0;
+        let accepted = 0;
+
+        const visit = (prefix, remaining) => {
+          if (remaining === 0) {
+            checked++;
+            const converted = variable('Converted');
+            const conversionGoal = compound('number_chars', [
+              converted,
+              listFromItems(Array.from(prefix, atom)),
+            ]);
+            let conversion;
+            try {
+              conversion = numberChars({ goal: conversionGoal, env: new Env() }).next();
+            } catch (_) {
+              return;
+            }
+            if (conversion.done) return;
+            accepted++;
+            const expected = copyResolved(converted, conversion.value);
+
+            stream.content = `${prefix}. `;
+            stream.position = 0;
+            stream.pastEnd = false;
+            const readValue = variable('ReadValue');
+            const readGoal = compound('read', [streamTerm, readValue]);
+            const answer = read({ solver, goal: readGoal, env: new Env() }).next();
+            if (answer.done) throw new Error(`read/2 rejected number_chars/2 spelling ${JSON.stringify(prefix)}`);
+            const actual = copyResolved(readValue, answer.value);
+            assertEqual(actual.type, 'number', `read/2 type for ${JSON.stringify(prefix)}`);
+            assertEqual(actual.name, expected.name, `read/2 value for ${JSON.stringify(prefix)}`);
+            return;
+          }
+          for (const character of alphabet) visit(prefix + character, remaining - 1);
+        };
+
+        for (let length = 1; length <= 4; length++) visit('', length);
+        assertEqual(checked, 88740, 'bounded numeric spellings checked');
+        if (accepted < 1000) throw new Error(`unexpectedly small accepted numeric corpus: ${accepted}`);
+      },
+    },
+    {
+      name: 'number_chars/2 to read/2 cross-check stays bounded under a small heap (issue #29)',
+      run: () => {
+        const engineUrl = new URL('../src/index.js', import.meta.url).href;
+        const script = `
+          import {
+            Program, Solver, Env, atom, compound, variable, listFromItems,
+            numberTerm, copyResolved, createDefaultRegistry,
+          } from ${JSON.stringify(engineUrl)};
+          const registry = createDefaultRegistry();
+          const numberChars = registry.get('number_chars', 2).handler;
+          const read = registry.get('read', 2).handler;
+          const solver = new Solver(Program.parse(''), { registry, ioOptions: { input: '' } });
+          const stream = solver.io.resolve(0);
+          const streamTerm = compound('$stream', [numberTerm('0')]);
+          for (let i = 0; i < 250000; i++) {
+            const text = String(i);
+            const converted = variable('Converted');
+            const conversionGoal = compound('number_chars', [
+              converted,
+              listFromItems(Array.from(text, atom)),
+            ]);
+            const conversion = numberChars({ goal: conversionGoal, env: new Env() }).next();
+            if (conversion.done) throw new Error('number_chars/2 failed at ' + i);
+            const expected = copyResolved(converted, conversion.value);
+
+            stream.content = text + '. ';
+            stream.position = 0;
+            stream.pastEnd = false;
+            const readValue = variable('ReadValue');
+            const readGoal = compound('read', [streamTerm, readValue]);
+            const answer = read({ solver, goal: readGoal, env: new Env() }).next();
+            if (answer.done) throw new Error('read/2 failed at ' + i);
+            const actual = copyResolved(readValue, answer.value);
+            if (actual.type !== 'number' || actual.name !== expected.name) {
+              throw new Error('number mismatch at ' + i + ': ' + actual.name + ' != ' + expected.name);
+            }
+          }
+          process.stdout.write('250000');
+        `;
+        const result = spawnSync(process.execPath, [
+          '--max-old-space-size=32',
+          '--input-type=module',
+          '--eval',
+          script,
+        ], { cwd: packageRoot, encoding: 'utf8', timeout: 30000 });
+        if (result.error) throw result.error;
+        assertEqual(result.status, 0, `bounded-heap child status; stderr=${result.stderr}`);
+        assertEqual(result.stdout, '250000', 'number_chars/read cross-check count');
+      },
+    },
     {
       name: 'number_chars and number_codes keep exponent floats syntactically readable (issue #50)',
       run: () => {
@@ -1897,11 +1999,13 @@ c4 ?- call((!;1)).
       },
     },
     {
-      name: 'predicates discard exhausted choicepoints before the REPL observes them (issue #74)',
+      name: 'direct and meta-called predicates discard exhausted choicepoints (issue #74 comment 5427164365)',
       run: () => {
         const result = runCli([], {
           input:
             'X=1;X=2.\n;\n' +
+            'call(X=1).\n' +
+            'call(=(X),1).\n' +
             'setof(X,true,Xs).\n' +
             'findall(t,false,Xs).\n' +
             'use_module(library(lists)).\n' +
@@ -1913,6 +2017,8 @@ c4 ?- call((!;1)).
         assertEqual(result.stdout,
           '?-    X = 1\n' +
           ';  X = 2.\n' +
+          '?-    X = 1.\n' +
+          '?-    X = 1.\n' +
           '?-    Xs = [_A].\n' +
           '?-    Xs = [].\n' +
           '?-    true.\n' +
@@ -1942,6 +2048,16 @@ c4 ?- call((!;1)).
         };
 
         finalAnswerHasNoFrames('', 'X=1;X=2', 2);
+        finalAnswerHasNoFrames('', 'call(X=1)', 1);
+        finalAnswerHasNoFrames('', 'call(=(X),1)', 1);
+        finalAnswerHasNoFrames('', 'atom_concat(a,X,ab)', 1);
+        finalAnswerHasNoFrames('', 'sub_atom(ab,0,2,0,S)', 1);
+        finalAnswerHasNoFrames('', 'current_prolog_flag(double_quotes,_Value)', 1);
+        finalAnswerHasNoFrames('', "current_op(700,xfx,'=')", 1);
+        finalAnswerHasNoFrames(':- dynamic(p/1).\np(a).', 'clause(p(X),true)', 1);
+        finalAnswerHasNoFrames(':- dynamic(p/1).\np(a).', 'retract(p(X))', 1);
+        finalAnswerHasNoFrames('', 'catch(true,_,fail)', 1);
+        finalAnswerHasNoFrames('', 'phrase([],[])', 1);
         finalAnswerHasNoFrames('', 'setof(X,true,Xs)', 1);
         finalAnswerHasNoFrames('', 'findall(t,false,Xs)', 1);
         finalAnswerHasNoFrames(':- use_module(library(lists)).', 'member(a,"ba")', 1, 'lists');
@@ -1954,6 +2070,82 @@ c4 ?- call((!;1)).
         assertEqual(groupedSolutions.next().done, false, 'first grouped setof/3 answer');
         assertEqual(grouped.hasPendingAlternatives(), true, 'genuine grouped setof/3 choicepoint');
         groupedSolutions.return();
+
+        const called = new Solver(Program.parse(''), { registry: getEyePrologRegistry() });
+        const calledSolutions = called.solve([parseGoalText('call((X=1;X=2))')], new Env(), 0);
+        assertEqual(calledSolutions.next().done, false, 'called disjunction first answer');
+        assertEqual(called.hasPendingAlternatives(), true, 'called disjunction retains its real alternative');
+        assertEqual(calledSolutions.next().done, false, 'called disjunction second answer');
+        assertEqual(called.hasPendingAlternatives(), false, 'called disjunction removes its exhausted alternative');
+        calledSolutions.return();
+
+        const customRegistry = new BuiltinRegistry();
+        customRegistry.add('single', 1, function* ({ goal, env }) {
+          const next = env.clone();
+          if (unify(goal.args[0], atom('only'), next)) yield next;
+        });
+        const custom = new Solver(Program.parse(''), { registry: customRegistry });
+        const customSolutions = custom.solve([parseGoalText('single(X)')], new Env(), 0);
+        assertEqual(customSolutions.next().done, false, 'custom relational iterator answer');
+        assertEqual(custom.hasPendingAlternatives(), false,
+          'unannotated relational iterator uses the universal lookahead protocol');
+        customSolutions.return();
+
+        const dynamicProgram = Program.parse(':- dynamic(p/1).\np(a).\np(b).\n');
+        const dynamicSolver = new Solver(dynamicProgram, { registry: getEyePrologRegistry() });
+        const dynamicSolutions = dynamicSolver.solve([parseGoalText('catch(retract(p(X)),_,fail)')], new Env(), 0);
+        assertEqual(dynamicSolutions.next().done, false, 'stateful protected iterator first answer');
+        assertEqual(dynamicProgram.findGroup('p', 1).clauses.length, 1,
+          'lookahead does not perform the next retraction');
+        assertEqual(dynamicSolver.hasPendingAlternatives(), true,
+          'stateful protected iterator retains its real second retraction');
+        dynamicSolutions.return();
+        assertEqual(dynamicProgram.findGroup('p', 1).clauses.length, 1,
+          'closing stateful iterator leaves the unrequested clause intact');
+      },
+    },
+    {
+      name: 'bound member tails do not invent predicate choicepoints (issue #74 follow-up)',
+      run: () => {
+        const result = runCli([], {
+          input:
+            'use_module(library(lists)).\n' +
+            'L=[i],append(L,_,[i|L]).\n' +
+            'L=[_],append(L,_,[i|L]).\n' +
+            'L=[i],append(L,_,[i|L]),member(a,[a|L]).\n' +
+            'L=[_],append(L,_,[i|L]),member(a,[a|L]).\n' +
+            'halt.\n',
+        });
+        assertEqual(result.status, 0, 'exit status');
+        assertEqual(result.stdout,
+          '?-    true.\n' +
+          '?-    L = "i".\n' +
+          '?-    L = "i".\n' +
+          '?-    L = "i".\n' +
+          '?-    L = "i".\n' +
+          '?- ',
+          'ground and formerly variable list elements have identical determinism');
+        assertEqual(result.stderr, '', 'stderr');
+      },
+    },
+    {
+      name: 'length/2 reports fixed and closed-list answers as deterministic (issue #78)',
+      run: () => {
+        const result = runCli([], {
+          input:
+            'use_module(library(lists)).\n' +
+            'length(K,0).\n' +
+            'length([],N).\n' +
+            'halt.\n',
+        });
+        assertEqual(result.status, 0, 'exit status');
+        assertEqual(result.stdout,
+          '?-    true.\n' +
+          '?-    K = [].\n' +
+          '?-    N = 0.\n' +
+          '?- ',
+          'no exhausted native length iterator remains');
+        assertEqual(result.stderr, '', 'stderr');
       },
     },
     {
@@ -3884,6 +4076,15 @@ child.stdin.write(\`consult(${consultedAtom}).\\n\`);
     {
       name: 'REPL answers use only lexically required operator spacing (issue #76)',
       run: () => {
+        const source = [
+          'emit :-',
+          '  write_term(1+1, [spacing(minimal)]), put_char(\'|\'),',
+          '  write_term(1+1, [spacing(standard)]).',
+          '',
+        ].join('\n');
+        assertEqual(run(source, { goal: 'emit' }).stdout, '1+1|1 + 1emit.\n',
+          'documented spacing values select write_term layout');
+
         const result = runCli([], {
           input: 'X=1*1.\nX=a + -b.\nhalt.\n',
         });
@@ -3894,6 +4095,24 @@ child.stdin.write(\`consult(${consultedAtom}).\\n\`);
           '?- ',
           'minimal operator layout preserves required token separation');
         assertEqual(result.stderr, '', 'stderr');
+
+        let variableError = null;
+        try {
+          run('', { goal: 'write_term(1+1,[spacing(X)])' });
+        } catch (error) {
+          variableError = error;
+        }
+        assertEqual(variableError?.formal, 'instantiation_error', 'variable spacing value');
+
+        for (const value of ['true', 'false', '1', '0']) {
+          let domainError = null;
+          try {
+            run('', { goal: `write_term(1+1,[spacing(${value})])` });
+          } catch (error) {
+            domainError = error;
+          }
+          assertEqual(domainError?.formal, 'domain_error(write_option)', `spacing(${value}) domain`);
+        }
       },
     },
     {
@@ -5189,6 +5408,7 @@ answer(ok) :-
       name: 'discarded recursive allocations recover after resource_error(memory)',
       run: () => {
         const engineUrl = new URL('../src/index.js', import.meta.url).href;
+        const platformUrl = new URL('../src/platform.js', import.meta.url).href;
         const programText = `
           :- use_module(library(prologue)).
           l([]).
@@ -5197,17 +5417,15 @@ answer(ok) :-
         const reportedGoal = 'length(_,I),N is 2^I,\\+ \\+ (length(L,N),l(L)),L=[_|_]';
         const script = `
           import { Program, Solver, Env, deref, variable, parseGoalText, getEyePrologRegistry } from ${JSON.stringify(engineUrl)};
+          import { usedHeapSize } from ${JSON.stringify(platformUrl)};
           const program = Program.parse(${JSON.stringify(programText)}, { sourceMetadata: false });
-          const solver = new Solver(program, { registry: getEyePrologRegistry() });
-          const execute = (text) => {
-            const goal = parseGoalText(text, { operatorDefinitions: [...program.operators.values()] });
-            return [...solver.solve([goal], new Env(), 0)];
-          };
+          const registry = getEyePrologRegistry();
           const reported = parseGoalText(${JSON.stringify(reportedGoal)}, {
             operatorDefinitions: [...program.operators.values()],
           });
+          const reportedSolver = new Solver(program, { registry, maxMemoryBytes: Infinity });
           let reportedAnswers = 0;
-          for (const answer of solver.solve([reported], new Env(), 0)) {
+          for (const answer of reportedSolver.solve([reported], new Env(), 0)) {
             reportedAnswers++;
             if (reportedAnswers !== 14) continue;
             if (deref(variable('I'), answer).name !== '13' || deref(variable('N'), answer).name !== '8192') {
@@ -5216,6 +5434,18 @@ answer(ok) :-
             break;
           }
           if (reportedAnswers !== 14) throw new Error('reported query produced too few answers');
+
+          // Exercise EyeProlog's recovery window at a stable threshold relative
+          // to the heap after the preliminary reproduction. Keeping that probe
+          // unlimited prevents host GC timing from exhausting the test early.
+          const solver = new Solver(program, {
+            registry,
+            maxMemoryBytes: usedHeapSize() + 8 * 1024 * 1024,
+          });
+          const execute = (text) => {
+            const goal = parseGoalText(text, { operatorDefinitions: [...program.operators.values()] });
+            return [...solver.solve([goal], new Env(), 0)];
+          };
           let caught = null;
           try { execute('length(L,32768),l(L)'); } catch (error) { caught = error; }
           if (caught?.formal !== 'resource_error(memory)') throw caught ?? new Error('no resource error');

package/the-art-of-eyeprolog.md

@@ -2017,7 +2017,12 @@ answer(X) :- host_status(service, X).
 ```
 
 Only mark a built-in deterministic when it can produce at most one environment
-for a call. A mode-sensitive extension can additionally provide `ready`,
+for a call. An unmarked resumable handler is treated as an effect-free relation:
+the solver may buffer one answer to determine its exact pending state. A
+stateful or meta-control handler must instead return an iterator with a
+`hasPendingAlternatives()` method, updated before each yield, so the solver can
+remain demand-driven without advancing it speculatively. A mode-sensitive
+extension can additionally provide `ready`,
 `fallbackWhenNotReady`, and `shouldUse` metadata. This metadata affects
 dispatch and safe early filtering, so it belongs to the extension's contract.
 
@@ -5136,8 +5141,12 @@ at a named boundary.
 ## 34. Control, exceptions, and grouped solutions
 
 The control predicates accept goals as arguments. `call/1` invokes a callable
-term, `once/1` keeps its first solution, and `!/0` commits within the clause
-that contains it. If-then-else commits to the first successful condition:
+term, and `call/2-8` appends arguments to a callable closure. The expanded goal
+runs in the current search continuation, so a direct goal and its meta-called
+form expose the same remaining alternatives; the meta-call still establishes
+its own cut boundary. `once/1` keeps its first solution, and `!/0` commits
+within the clause that contains it. If-then-else commits to the first successful
+condition:
 
 <figure>
   <img src="book-assets/iso-control-board.svg" alt="A goal passes through choice and exception recovery before finite solutions enter findall, bagof, and setof collectors.">
@@ -5187,8 +5196,10 @@ pruned, top-level answer enumeration is abandoned, or an exception unwinds the
 search. `setup_call_cleanup/3` runs Setup once and installs Cleanup only after
 Setup succeeds. On cut or ordinary pruning Cleanup sees the current Goal
 bindings; on exception unwind the Goal bindings have been removed and Cleanup
-sees the Setup environment. Cleanup failure is ignored, and an exception already
-being propagated takes precedence over a cleanup exception. Nested cleanups run
+sees the Setup environment. When a deterministic protected goal runs Cleanup
+before yielding, substitutions produced by a successful Cleanup are included in
+that answer. Cleanup failure is ignored, and an exception already being
+propagated takes precedence over a cleanup exception. Nested cleanups run
 inside-out. These two controls are EyeProlog extensions and are absent from
 `--iso-strict`.
 
@@ -5427,9 +5438,15 @@ still retained where adjacent graphic tokens would otherwise merge, as in
 `variable_names/1`. Normal mode additionally accepts the EyeProlog extension
 `double_quotes(true|false)`: `true` lets eligible character/code lists use the
 current `double_quotes` representation, while strict ISO mode rejects this
-non-standard write option. The REPL follows the same minimal-separator rule as
-term output, so `X=1*1` is displayed as `X = 1*1`, while a separator is retained
-in `X = a+ -b` because the adjacent graphic tokens would otherwise merge.
+implementation-specific write option. Normal mode also accepts the
+implementation-specific `spacing(minimal|standard)` option: `minimal` emits
+only separators required to avoid lexical ambiguity, while `standard` adds
+conventional layout around operators. For example,
+`write_term(1+1,[spacing(minimal)])` emits `1+1` and
+`write_term(1+1,[spacing(standard)])` emits `1 + 1`. The REPL always follows
+the minimal-separator rule, so `X=1*1` is displayed as `X = 1*1`, while a
+separator is retained in `X = a+ -b` because the adjacent graphic tokens would
+otherwise merge. Strict ISO mode rejects both extension options.
 
 Character operations are `get_char`, `peek_char`, `put_char`, `get_code`,
 `peek_code`, and `put_code`; byte streams use the corresponding byte
@@ -6122,7 +6139,7 @@ the beginning. A peek does not mark the stream as past-end.
 | `write(+Term)`, `write(+Stream,+Term)` | Writes readable operator notation without quoting atoms merely because quoting would be required for reparsing. Number variables are enabled. |
 | `writeq(+Term)`, `writeq(+Stream,+Term)` | Like `write`, but quotes atoms when required for unambiguous input syntax. |
 | `write_canonical(+Term)`, `write_canonical(+Stream,+Term)` | Writes quoted canonical functor notation while ignoring operators and without interpreting *$VAR/1*. |
-| `write_term(+Term,+Options)`, `write_term(+Stream,+Term,+Options)` | Writes with *quoted(true or false)*, *ignore_ops(true or false)*, *numbervars(true or false)*, and *variable_names([Name=Variable,...])*. Normal mode also supports *double_quotes(true or false)*. |
+| `write_term(+Term,+Options)`, `write_term(+Stream,+Term,+Options)` | Writes with *quoted(true or false)*, *ignore_ops(true or false)*, *numbervars(true or false)*, and *variable_names([Name=Variable,...])*. Normal mode also supports *double_quotes(true or false)* and *spacing(minimal or standard)*. |
 
 Term input uses the program's current operator table and the same ISO quoted-character
 syntax as source text, including backslash-terminated octal and hexadecimal
@@ -6132,6 +6149,12 @@ when the `char_conversion` flag is `on`. `variable_names/1` and `singletons/1` o
 predicates do not append a period or newline; call `write/1`, then `write('.')`
 and `nl/0` when emitting a complete source term manually.
 
+A standalone numeric term read by `read/1-2` or `read_term/2-3` uses the same
+bounded numeric scanner and canonical value conversion as `number_chars/2`.
+Consequently every numeric character sequence accepted by `number_chars/2` has
+the same value when read as a full-stop-terminated term, without requiring EOF
+after that term.
+
 ### Arithmetic expressions
 
 | Predicate and principal call | Behavior |
@@ -6209,7 +6232,7 @@ so side effects occur in Prolog execution order.
 
 ### Normal-mode cleanup controls
 
-`call_cleanup/2` and `setup_call_cleanup/3` are normal EyeProlog runtime extensions rather than members of the isolated ISO builtin registry. They protect a goal across deterministic completion, exhaustion, cut, top-level abandonment, and exception unwinding, running Cleanup exactly once. `setup_call_cleanup/3` runs Setup once and installs Cleanup only after Setup succeeds. Nested cleanups run inside-out, and strict ISO mode does not provide either predicate.
+`call_cleanup/2` and `setup_call_cleanup/3` are normal EyeProlog runtime extensions rather than members of the isolated ISO builtin registry. They protect a goal across deterministic completion, exhaustion, cut, top-level abandonment, and exception unwinding, running Cleanup exactly once. `setup_call_cleanup/3` runs Setup once and installs Cleanup only after Setup succeeds. A successful Cleanup run before a deterministic answer contributes its substitutions to that answer. Nested cleanups run inside-out, and strict ISO mode does not provide either predicate.
 
 ### The EyeProlog library
 
@@ -6363,7 +6386,9 @@ conservative cross-engine subset.
 `length(Xs, N)` enumerates `Xs = [], N = 0`, then one-element lists with
 `N = 1`, and so on. Open-ended generation uses the normal memory guard with
 recovery headroom so finite-heap exhaustion remains a catchable
-`resource_error(memory)`.
+`resource_error(memory)`. A supplied nonnegative length selects at most one
+answer, and a supplied closed list has exactly one length; these modes do not
+retain an exhausted choicepoint.
 
 `library(iso_ext)` is a common interop module name, but only part of its
 EyeProlog API belongs to the shared profile. `call_nth/2`, `time/1`, and
@@ -6815,11 +6840,15 @@ When another answer exists in an interactive terminal, press `;`, Space, or
 enumeration, `a` enumerates all remaining answers, and `f` advances to the
 next five-answer boundary (5, 10, 15, ... displayed leaf answers), regardless
 of how many answers were stepped through individually beforehand. `h` displays
-the answer-control help. Enumeration is demand-driven: after an answer is
-found, the top level does not pull a successor merely to discover whether the
-current answer is the last one. Search for a later answer, including any side
-effects reached on that path, starts only after an answer-control command asks
-to continue. Stopping enumeration closes any active `call_cleanup/2` or
+the answer-control help. Enumeration of goal continuations is demand-driven:
+after an answer is found, the top level does not execute a later program branch
+or side effect merely to discover whether the current answer is the last one.
+The solver's uniform choicepoint protocol uses explicit clause and control
+frames, permits a one-answer buffer only for effect-free host relations, and
+requires stateful or meta-control iterators to report their pending state
+directly. Search that can perform an effect starts only after an answer-control
+command asks to continue. Stopping enumeration closes any active
+`call_cleanup/2` or
 `setup_call_cleanup/3` protection exactly once; detecting that a choicepoint
 remains does not execute that next branch. If an unresolved alternative
 ultimately has no solution, asking for it may therefore finish with `false.`. In scripted non-TTY input, a new
@@ -7767,8 +7796,8 @@ Notable implementation boundaries are:
 - `write_term/2-3` implements the Part 1 plus Corrigendum 3 `quoted/1`,
   `ignore_ops/1`, `numbervars/1`, and `variable_names/1` option surface,
   including option validation and traversal rules; normal mode also offers
-  `double_quotes(true|false)` as an explicitly non-standard extension, which
-  strict mode rejects;
+  `double_quotes(true|false)` and `spacing(minimal|standard)` as explicitly
+  implementation-specific extensions, which strict mode rejects;
 - unification consistently performs an occurs check, rejecting rational-tree
   bindings accepted as extensions by some systems.
 
@@ -7979,8 +8008,11 @@ decidable by structural equality.
 **Clause.** A fact or rule terminated by a period.
 
 **Choicepoint.** A remaining search alternative that may produce another
-answer if the caller asks the solver to continue. EyeProlog's top level reports
-choicepoint availability without speculatively executing the next alternative.
+answer if the caller asks the solver to continue. Every resumable engine
+iterator follows the same pending-alternative protocol. Ordinary effect-free
+host relations may buffer one answer to prove exhaustion; stateful and
+meta-control iterators report their state without executing an unrequested
+effect or program branch.
 
 **Cleanup.** A protected finalization goal installed by normal-mode
 `call_cleanup/2` or `setup_call_cleanup/3`. It runs exactly once when the