eyeprolog 1.3.83 → 1.3.85

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.3.83",
+  "version": "1.3.85",
   "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

@@ -804,7 +804,18 @@ function* currentPrologFlagBuiltin({ solver, goal, env }) {
 }
 
 function* setPrologFlagBuiltin({ solver, goal, env }) {
-  solver.setPrologFlag(goal.args[0], goal.args[1], env);
+  const flag = deref(goal.args[0], env);
+  const value = deref(goal.args[1], env);
+  if (flag.type === VAR || value.type === VAR) throw new PrologError('instantiation_error');
+  if (flag.type !== ATOM) throw new PrologError('type_error(atom)', flag);
+  const definition = solver.prologFlags.get(flag.name);
+  if (!definition) throw new PrologError('domain_error(prolog_flag)', flag);
+  const expectedType = definition.valueType ?? ATOM;
+  if (value.type !== expectedType || !definition.allowed.includes(value.name)) {
+    throw new PrologError('domain_error(flag_value)', compound('+', [flag, value]));
+  }
+  if (!definition.changeable) throw new PrologError('permission_error(modify, flag)', flag);
+  definition.value = atom(value.name);
   yield env;
 }
 
@@ -1544,6 +1555,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,
@@ -1712,7 +1741,7 @@ function writeOptionBoolean(value, env, option) {
 function writeOptionSpacing(value, env, option) {
   value = deref(value, env);
   if (value.type === VAR) throw new PrologError('instantiation_error');
-  if (value.type !== ATOM || !['standard', 'minimal'].includes(value.name)) {
+  if (value.type !== ATOM || !['minimal', 'standard'].includes(value.name)) {
     throw new PrologError('domain_error(write_option)', copyResolved(option, env));
   }
   return value.name;
@@ -1746,10 +1775,8 @@ function writeVariableNames(value, env, option) {
   return names;
 }
 
-function termWriteOptionsFromItems(options, env, mode = 'write_term', solver = null, initial = null) {
-  const result = initial == null
-    ? defaultTermWriteOptions(mode)
-    : { ...initial, variableNames: new Map(initial.variableNames ?? []) };
+function termWriteOptionsFromItems(options, env, mode = 'write_term', solver = null) {
+  const result = defaultTermWriteOptions(mode);
   for (const option of options) {
     if (option.type !== COMPOUND || option.arity !== 1) {
       throw new PrologError('domain_error(write_option)', copyResolved(option, env));
@@ -1769,12 +1796,6 @@ function termWriteOptionsFromItems(options, env, mode = 'write_term', solver = n
   return result;
 }
 
-export function parseTermWriteOptions(optionTerm, env, mode = 'write_term', solver = null, initial = null) {
-  const preflight = preflightOptionList(optionTerm, env);
-  const items = requireProperOptionList(preflight);
-  return termWriteOptionsFromItems(items, env, mode, solver, initial);
-}
-
 
 function writeBuiltin(mode) {
   return function* ({ solver, goal, env }) {

package/src/repl.js

@@ -3,7 +3,7 @@ import fs from 'node:fs/promises';
 import { readSync } from 'node:fs';
 import path from 'node:path';
 import { createInterface } from 'node:readline';
-import { formalErrorTerm, parseTermWriteOptions } from './iso.js';
+import { formalErrorTerm } from './iso.js';
 import {
   characterCodeConstantEnd, continuesGraphicToken, isTerminatingFullStop, quotedEscapeEnd,
 } from './syntax-scan.js';
@@ -303,18 +303,20 @@ function makeState(engine, sources, output, options = {}, previousState = null,
   const flagOverrides = new Map(previousState?.flagOverrides ?? []);
   for (const [name, value] of flagOverrides) {
     const definition = solver.prologFlags.get(name);
-    if (definition?.changeable) definition.value = value;
+    if (definition?.changeable && definition.allowed.includes(value)) {
+      definition.value = engine.atom(value);
+    }
   }
   return { program: solver.program, solver, strictIso, flagOverrides };
 }
 
 function snapshotFlagValues(solver) {
-  return new Map([...solver.prologFlags].map(([name, definition]) => [name, definition.value]));
+  return new Map([...solver.prologFlags].map(([name, definition]) => [name, definition.value?.name]));
 }
 
 function rememberFlagOverrides(state, before) {
   for (const [name, definition] of state.solver.prologFlags) {
-    const value = definition.value;
+    const value = definition.value?.name;
     if (before.get(name) !== value) state.flagOverrides.set(name, value);
   }
 }
@@ -718,7 +720,15 @@ function formatAnswer(engine, state, variables, env) {
   const valueMaxPriority = equality == null
     ? 699
     : equality.specifier === 'xfy' ? equality.priority : equality.priority - 1;
-  const writeOptions = answerTermWriteOptions(state, env);
+  const answerWriteOptions = {
+    quoted: true,
+    minimalOperatorSpacing: true,
+    operators,
+    variableNames: names,
+    operatorAtomsAsArgs: true,
+    dottedGraphicAtoms: true,
+    doubleQuotes: state.solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
+  };
   let generated = 0;
 
   // Meta-predicate wrappers can make a query variable alias an internal fresh
@@ -733,28 +743,18 @@ function formatAnswer(engine, state, variables, env) {
     if (value.type === 'var' &&
         (value.name === variable.name || !queryVariableNames.has(value.name))) continue;
     bindings.push(`${variable.name} = ${engine.formatTermForWrite(value, env, {
-      ...writeOptions,
-      operators,
-      variableNames: names,
+      ...answerWriteOptions,
       maxPriority: valueMaxPriority,
       // A binding value is the right-hand `arg` of =/2.  ISO 6.3.3.1 permits
       // current operator atoms in argument and list-element positions without
       // quotes, just as writeq/1 already prints them.
-      operatorAtomsAsArgs: true,
-      dottedGraphicAtoms: true,
     })}`);
   }
   for (const constraint of env.variableConstraints?.() ?? []) {
     const residual = constraint.residualGoal?.(env);
     if (residual == null) continue;
     collectUnboundVariables(engine, residual, env, names, () => `_${letterName(generated++)}`);
-    bindings.push(engine.formatTermForWrite(residual, env, {
-      ...writeOptions,
-      operators,
-      variableNames: names,
-      operatorAtomsAsArgs: true,
-      dottedGraphicAtoms: true,
-    }));
+    bindings.push(engine.formatTermForWrite(residual, env, answerWriteOptions));
   }
   const projectedAttributeRoots = new Set();
   for (const variable of variables) {
@@ -764,38 +764,12 @@ function formatAnswer(engine, state, variables, env) {
     names.set(root.name, variable.name);
     for (const residual of state.solver.attributeResidualGoals(root, env)) {
       collectUnboundVariables(engine, residual, env, names, () => `_${letterName(generated++)}`);
-      bindings.push(engine.formatTermForWrite(residual, env, {
-        ...writeOptions,
-        operators,
-        variableNames: names,
-        operatorAtomsAsArgs: true,
-        dottedGraphicAtoms: true,
-      }));
+      bindings.push(engine.formatTermForWrite(residual, env, answerWriteOptions));
     }
   }
   return bindings.length === 0 ? 'true' : bindings.join(', ');
 }
 
-function answerTermWriteOptions(state, env) {
-  const doubleQuotes = state.solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars';
-  const initial = {
-    quoted: true,
-    ignoreOps: false,
-    numbervars: true,
-    variableNames: new Map(),
-    compact: false,
-    minimalOperatorSpacing: false,
-    operatorAtomsAsArgs: true,
-    doubleQuotes,
-  };
-  const optionTerm = state.solver.prologFlags.get('answer_write_options')?.value;
-  if (optionTerm == null) return initial;
-  const options = parseTermWriteOptions(optionTerm, env, 'write_term', state.solver, initial);
-  if (options.doubleQuotes === true) options.doubleQuotes = doubleQuotes;
-  else if (options.doubleQuotes === false) options.doubleQuotes = null;
-  return options;
-}
-
 function collectUnboundVariables(engine, term, env, names, nextName) {
   const stack = [term];
   const seen = new Set();

package/src/solver.js

@@ -1,12 +1,12 @@
 // Depth-first EyeProlog solver with builtin dispatch, memoization, and guarded recursion handling.
 // Most semantic decisions still flow through unification; optimizations only select candidates earlier.
 import {
-  ATOM, COMPOUND, NUMBER, STRING, VAR, Env, atom, compactListLength, compactVariableList, compound, cons, copyResolved, deref, emptyList,
+  ATOM, COMPOUND, NUMBER, STRING, VAR, Env, compactListLength, compactVariableList, compound, cons, copyResolved, deref, emptyList,
   flattenConjunction, freshTerm, isCons, isDecimalInteger, isEmptyList,
-  listFromItems, numberTerm, numberTextFromDouble, properListItems, termIsGround, termToString, unify, variable, variantTerms,
+  numberTerm, numberTextFromDouble, properListItems, termIsGround, termToString, unify, variable, variantTerms,
 } from './term.js';
 import { numberValueKey, sameNumberValue } from './number-value.js';
-import { PrologError, getStrictIsoRegistry, parseTermWriteOptions } from './iso.js';
+import { PrologError, getStrictIsoRegistry } from './iso.js';
 import { getEyePrologRegistry } from './standard-library.js';
 import { selectClauseCandidates, selectClauseCandidatesForValues, selectGroundClauseCandidates } from './program-indexing.js';
 import { StreamManager } from './io.js';
@@ -144,7 +144,15 @@ export class Solver {
         this.prologFlags.get('double_quotes').value = compound(program.doubleQuotes, []);
       }
       for (const [flag, value] of program.prologFlagDirectives ?? []) {
-        this.setPrologFlag(flag, value, new Env());
+        if (flag.type === 'var' || value.type === 'var') throw new PrologError('instantiation_error');
+        if (flag.type !== 'atom') throw new PrologError('type_error(atom)', flag);
+        const definition = this.prologFlags.get(flag.name);
+        if (!definition) throw new PrologError('domain_error(prolog_flag)', flag);
+        if (value.type !== 'atom' || !definition.allowed.includes(value.name)) {
+          throw new PrologError('domain_error(flag_value)', compound('+', [flag, value]));
+        }
+        if (!definition.changeable) throw new PrologError('permission_error(modify, flag)', flag);
+        definition.value = value;
       }
     }
     if (!options.charConversions) {
@@ -198,35 +206,6 @@ export class Solver {
     };
   }
 
-  setPrologFlag(flagTerm, valueTerm, env = new Env()) {
-    const flag = deref(flagTerm, env);
-    const value = deref(valueTerm, env);
-    if (flag.type === VAR || value.type === VAR) throw new PrologError('instantiation_error');
-    if (flag.type !== ATOM) throw new PrologError('type_error(atom)', flag);
-    const definition = this.prologFlags.get(flag.name);
-    if (!definition) throw new PrologError('domain_error(prolog_flag)', flag);
-
-    if (definition.writeOptions === true) {
-      if (!termIsGround(value, env)) throw new PrologError('instantiation_error');
-      try {
-        parseTermWriteOptions(value, env, 'write_term', this);
-      } catch (error) {
-        if (error instanceof PrologError && error.formal === 'instantiation_error') throw error;
-        throw new PrologError('domain_error(flag_value)', compound('+', [flag, copyResolved(value, env)]));
-      }
-      if (!definition.changeable) throw new PrologError('permission_error(modify, flag)', flag);
-      definition.value = copyResolved(value, env);
-      return;
-    }
-
-    const expectedType = definition.valueType ?? ATOM;
-    if (value.type !== expectedType || !definition.allowed.includes(value.name)) {
-      throw new PrologError('domain_error(flag_value)', compound('+', [flag, value]));
-    }
-    if (!definition.changeable) throw new PrologError('permission_error(modify, flag)', flag);
-    definition.value = atom(value.name);
-  }
-
   cloneForInnerGoal(solutionLimit = this.solutionLimit, options = {}) {
     const solver = new Solver(this.program, {
       registry: this.registry,
@@ -1093,12 +1072,6 @@ function defaultPrologFlags(unknown = 'error', strictIso = false) {
     ['unknown', { value: compound(unknown, []), allowed: ['error', 'fail', 'warning'], changeable: true }],
     ['double_quotes', { value: compound('chars', []), allowed: ['chars', 'codes', 'atom'], changeable: true }],
     ['occurs_check', { value: compound('true', []), allowed: ['true', 'error'], changeable: true }],
-    ['answer_write_options', {
-      value: listFromItems([compound('spacing', [compound('standard', [])])]),
-      allowed: [],
-      changeable: true,
-      writeOptions: true,
-    }],
   ]);
   if (strictIso) flags.delete('occurs_check');
   return flags;
@@ -1522,12 +1495,29 @@ function* bundledMemberSolutions(solver, goal, env, state) {
 
 function bundledMemberMayMatch(target, cursor, env) {
   while (isCons(cursor)) {
-    if (!goalHeadTermsCannotMatch(target, cursor.args[0], env)) return true;
+    if (!termsCannotUnify(target, cursor.args[0], env)) return true;
     cursor = deref(cursor.args[1], env);
   }
   return false;
 }
 
+function termsCannotUnify(left, right, env) {
+  const pending = [[left, right]];
+  while (pending.length > 0) {
+    const [leftItem, rightItem] = pending.pop();
+    const actualLeft = derefForLocal(leftItem, env);
+    const actualRight = derefForLocal(rightItem, env);
+    if (actualLeft.type === VAR || actualRight.type === VAR) continue;
+    if (actualLeft.type !== actualRight.type || actualLeft.name !== actualRight.name ||
+        actualLeft.arity !== actualRight.arity) return true;
+    if (actualLeft.type !== COMPOUND) continue;
+    for (let index = 0; index < actualLeft.arity; index++) {
+      pending.push([actualLeft.args[index], actualRight.args[index]]);
+    }
+  }
+  return false;
+}
+
 function bundledEllipsisPlan(solver, group, goal, rest, env) {
   if (solver.registry.eyePrologLibrary !== true ||
       group.module !== 'iso_ext' || group.name !== '...' || group.arity !== 2 ||
@@ -1640,7 +1630,13 @@ function bundledLengthIterator(solver, group, goal, env) {
       if (length.type === VAR && cursor.name === length.name) return null;
     }
   }
-  return bundledLengthSolutions(solver, goal, env);
+  const iterator = bundledLengthSolutions(solver, goal, env);
+  // A supplied length selects at most one list, and a closed supplied list has
+  // exactly one length. Only an open list paired with an output variable can
+  // produce another answer after the first one.
+  const hasOpenTail = cursor.type === VAR;
+  iterator.hasPendingAlternatives = () => length.type === VAR && hasOpenTail;
+  return iterator;
 }
 
 function* bundledLengthSolutions(solver, goal, env) {

package/test/conformance/ISO-COMPLIANCE.md

@@ -98,7 +98,7 @@ 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` and `spacing/1` write options remain explicitly documented
-EyeProlog extensions.
+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

@@ -120,11 +120,11 @@ families; `--iso-strict` is intended to remove their Part 1 interpretation.
 | 5.5.5 Directives | `module/2`, `use_module/1-2`, `meta_predicate/1` and normal-profile library behavior | Rejected as implementation-specific Part 1 directives. |
 | 5.5.6 Side effects | Normal mode adds `statistics/0-2`, cleanup/library state, and optional proof/statistics host instrumentation. | The strict registry excludes Prolog-visible statistics/cleanup/library adapters; ordinary Part 1 I/O/database/flag/operator side effects remain. Host proof/statistics collection observes execution through the embedding API rather than adding a strict Prolog goal effect. **covered** — strict registry/execution regression. |
 | 5.5.7 Control constructs | `tnot/1` and normal-profile execution optimizations | `tnot/1` is absent; automatic tabling/recursion guards are disabled. |
-| 5.5.8 Flags | `occurs_check`; `answer_write_options`, whose normal-mode default is `[spacing(standard)]` and whose value controls REPL answer rendering | Both extension flags are absent in strict mode. |
+| 5.5.8 Flags | `occurs_check` | Absent in strict mode. |
 | 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` options `double_quotes(true|false)` and `spacing(standard|minimal)`. Strict core excludes those extensions 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/conformance/expected/iso/exceptions_and_flags.pl

@@ -1,3 +1,3 @@
 answer(7, red, caught(eyeprolog), first, caught(eyeprolog)).
 answer(7, red, caught(eyeprolog), second, caught(eyeprolog)).
-flags(off, on, [pair(bounded, false), pair(integer_rounding_function, toward_zero), pair(char_conversion, on), pair(debug, off), pair(max_arity, unbounded), pair(unknown, fail), pair(double_quotes, chars), pair(occurs_check, true), pair(answer_write_options, [spacing(standard)])]).
+flags(off, on, [pair(bounded, false), pair(integer_rounding_function, toward_zero), pair(char_conversion, on), pair(debug, off), pair(max_arity, unbounded), pair(unknown, fail), pair(double_quotes, chars), pair(occurs_check, true)]).

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

@@ -41,7 +41,6 @@ export function runIsoStrict(reporter = new TestReporter()) {
   reporter.test('exposes only ISO core Prolog flags', () => {
     const solver = new Solver(Program.parse('', { isoStrict: true }), { isoStrict: true });
     equal(solver.prologFlags.has('occurs_check'), false, 'occurs_check');
-    equal(solver.prologFlags.has('answer_write_options'), false, 'answer_write_options');
     equal(solver.prologFlags.get('unknown')?.value?.name, 'error', 'unknown default');
   });
 
@@ -286,14 +285,14 @@ export function runIsoStrict(reporter = new TestReporter()) {
 
     const strictSpacingError = capture(() => run('', {
       isoStrict: true,
-      goal: 'write_term(1*1,[spacing(minimal)])',
+      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');
+    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

@@ -186,7 +186,7 @@ function regressionCases() {
         });
         assertEqual(residuals.status, 0, 'dif/2 residual display status');
         assertEqual(residuals.stdout,
-          '?-    C = z, D = z, dif(A - z, B - z).\n' +
+          '?-    C = z, D = z, dif(A-z, B-z).\n' +
           '?-    A = [[]], B = [], dif([[]], [C]).\n' +
           '?-    X = Y.\n' +
           '?- ',
@@ -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: () => {
@@ -1449,7 +1551,7 @@ c4 ?- call((!;1)).
           input: 'read(T).\n!,*.\n.\nread(T).\na\n.\nhalt.\n',
         });
         assertEqual(continuedGraphic.status, 0, 'continued graphic operator REPL status');
-        assertIncludes(continuedGraphic.stdout, 'T = (!, *.).', 'continued graphic operator answer');
+        assertIncludes(continuedGraphic.stdout, 'T = (!,*.).', 'continued graphic operator answer');
         assertIncludes(continuedGraphic.stdout, 'T = a.', 'read after continued graphic operator');
         assertNotIncludes(continuedGraphic.stdout, 'syntax_error', 'continued graphic operator syntax');
         assertEqual(continuedGraphic.stderr, '', 'continued graphic operator REPL stderr');
@@ -1956,6 +2058,50 @@ c4 ?- call((!;1)).
         groupedSolutions.return();
       },
     },
+    {
+      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');
+      },
+    },
     {
       name: 'REPL hides aliases to fresh throw variables while preserving query aliases',
       run: () => {
@@ -2456,10 +2602,10 @@ c4 ?- call((!;1)).
         });
         assertEqual(result.status, 0, 'exit status');
         assertEqual(result.stdout,
-          '?-    T = (a = b).\n' +
-          '?-    U = (a, b).\n' +
-          '?-    V = (a ; b).\n' +
-          '?-    W = a + b.\n' +
+          '?-    T = (a=b).\n' +
+          '?-    U = (a,b).\n' +
+          '?-    V = (a;b).\n' +
+          '?-    W = a+b.\n' +
           '?- ',
           'stdout');
         assertEqual(result.stderr, '', 'stderr');
@@ -2665,9 +2811,9 @@ c4 ?- call((!;1)).
         });
         assertEqual(result.status, 0, 'exit status');
         assertEqual(result.stdout,
-          '?-   |:  X = (_A = a).\n' +
-          '?-   |:  X = (_A = a).\n' +
-          "?-   |:  X = (_A = pair(_A, _B)), Vs = [_A, _B], Names = ['X' = _A, 'Y' = _B], Singletons = ['Y' = _B].\n" +
+          '?-   |:  X = (_A=a).\n' +
+          '?-   |:  X = (_A=a).\n' +
+          "?-   |:  X = (_A=pair(_A, _B)), Vs = [_A, _B], Names = ['X'=_A, 'Y'=_B], Singletons = ['Y'=_B].\n" +
           '?- ',
           'stdout');
         assertEqual(result.stderr, '', 'stderr');
@@ -3882,67 +4028,45 @@ child.stdin.write(\`consult(${consultedAtom}).\\n\`);
       },
     },
     {
-      name: 'answer write options make operator spacing explicit and persistent (issue #76)',
+      name: 'REPL answers use only lexically required operator spacing (issue #76)',
       run: () => {
         const source = [
           'emit :-',
-          '  write_term(1*1, [spacing(standard)]), put_char(\'|\'),',
-          '  write_term(1*1, [spacing(minimal)]), put_char(\'|\'),',
-          '  write_term(1*1, [spacing(standard),spacing(minimal)]).',
+          '  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*1|1*1emit.\n',
-          'explicit and rightmost spacing options');
-        assertEqual(run([
-          ':- set_prolog_flag(answer_write_options, [spacing(minimal)]).',
-          'emit :- current_prolog_flag(answer_write_options, [spacing(minimal)]).',
-        ], { goal: 'emit' }).stdout, 'emit.\n', 'source flag directive');
+        assertEqual(run(source, { goal: 'emit' }).stdout, '1+1|1 + 1emit.\n',
+          'documented spacing values select write_term layout');
 
         const result = runCli([], {
-          input:
-            'current_prolog_flag(answer_write_options, Os).\n' +
-            'X=1*1.\n' +
-            'set_prolog_flag(answer_write_options,[spacing(minimal)]).\n' +
-            'use_module(library(lists)).\n' +
-            'X=1*1.\n' +
-            'current_prolog_flag(answer_write_options, Os).\n' +
-            'halt.\n',
+          input: 'X=1*1.\nX=a + -b.\nhalt.\n',
         });
         assertEqual(result.status, 0, 'exit status');
         assertEqual(result.stdout,
-          '?-    Os = [spacing(standard)].\n' +
-          '?-    X = 1 * 1.\n' +
-          '?-    true.\n' +
-          '?-    true.\n' +
           '?-    X = 1*1.\n' +
-          '?-    Os = [spacing(minimal)].\n' +
+          '?-    X = a+ -b.\n' +
           '?- ',
-          'discoverable top-level option and persistence across module reload');
+          'minimal operator layout preserves required token separation');
         assertEqual(result.stderr, '', 'stderr');
 
-        let writeOptionError = null;
-        try {
-          run('', { goal: 'write_term(a,[spacing(other)])' });
-        } catch (error) {
-          writeOptionError = error;
-        }
-        assertEqual(writeOptionError?.formal, 'domain_error(write_option)', 'spacing value domain');
-
-        let flagValueError = null;
+        let variableError = null;
         try {
-          run('', { goal: 'set_prolog_flag(answer_write_options,[spacing(other)])' });
+          run('', { goal: 'write_term(1+1,[spacing(X)])' });
         } catch (error) {
-          flagValueError = error;
+          variableError = error;
         }
-        assertEqual(flagValueError?.formal, 'domain_error(flag_value)', 'answer option flag domain');
+        assertEqual(variableError?.formal, 'instantiation_error', 'variable spacing value');
 
-        let nongroundFlagError = null;
-        try {
-          run('', { goal: 'set_prolog_flag(answer_write_options,[spacing(X)])' });
-        } catch (error) {
-          nongroundFlagError = error;
+        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`);
         }
-        assertEqual(nongroundFlagError?.formal, 'instantiation_error', 'answer options must be ground');
       },
     },
     {
@@ -5238,6 +5362,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([]).
@@ -5246,8 +5371,14 @@ 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() });
+          // Exercise EyeProlog's recovery window at a stable threshold instead
+          // of relying on V8's version-dependent old-generation promotion.
+          const solver = new Solver(program, {
+            registry: getEyePrologRegistry(),
+            maxMemoryBytes: usedHeapSize() + 20 * 1024 * 1024,
+          });
           const execute = (text) => {
             const goal = parseGoalText(text, { operatorDefinitions: [...program.operators.values()] });
             return [...solver.solve([goal], new Env(), 0)];

package/the-art-of-eyeprolog.md

@@ -5187,8 +5187,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`.
 
@@ -5426,10 +5428,16 @@ still retained where adjacent graphic tokens would otherwise merge, as in
 `write_term/2-3` supports `quoted/1`, `ignore_ops/1`, `numbervars/1`, and
 `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. It also accepts
-`spacing(standard|minimal)`: `standard` places layout around operators, while
-`minimal` emits only the separators required to avoid lexical ambiguity.
-Strict ISO mode rejects both non-standard write options.
+current `double_quotes` representation, while strict ISO mode rejects this
+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
@@ -6002,7 +6010,7 @@ silently changing a static program.
 | `char_conversion(+Input,+Output)` | Installs a one-character conversion. In prepared Prolog text, later **unquoted** characters are converted when `char_conversion=on`; quoted characters are unchanged. The same mapping initializes execution-time term input. Mapping a character to itself removes its custom mapping. |
 | `current_char_conversion(?Input,?Output)` | Enumerates installed nonidentity conversions. |
 | `current_prolog_flag(?Flag,?Value)` | Enumerates flags or retrieves one named flag. An unknown bound flag raises *domain_error(prolog_flag)*. |
-| `set_prolog_flag(+Flag,+Value)` | Changes a supported mutable flag after validating its value. Read-only flags raise a permission error. |
+| `set_prolog_flag(+Flag,+Value)` | Changes a supported mutable flag after validating its allowed atom value. Read-only flags raise a permission error. |
 
 | Flag | Default in normal EyeProlog | Allowed values | Mutable |
 | --- | --- | --- | --- |
@@ -6016,7 +6024,6 @@ silently changing a static program.
 | `unknown` | `error` | `error`, `fail`, `warning` | yes |
 | `double_quotes` | `chars` | `chars`, `codes`, `atom` | yes |
 | `occurs_check` | `true` | `true`, `error` | yes |
-| `answer_write_options` | `[spacing(standard)]` | A ground proper list of supported normal-mode `write_term/2-3` options | yes |
 
 Because `bounded=false`, `current_prolog_flag(max_integer, _)` and
 `current_prolog_flag(min_integer, _)` fail as required by ISO 7.11.1.1;
@@ -6051,24 +6058,6 @@ codes("ab").                 % codes([97,98])
 quoted_atom("ab").           % quoted_atom(ab)
 ```
 
-Normal mode also exposes the REPL's term-writing options through the mutable
-`answer_write_options` flag. Its explicit default explains the spaces in an
-answer such as `X = 1 * 1`; selecting minimal spacing is discoverable and
-reusable from Prolog:
-
-```text
-?- current_prolog_flag(answer_write_options, Options).
-   Options = [spacing(standard)].
-?- set_prolog_flag(answer_write_options, [spacing(minimal)]).
-   true.
-?- X = 1*1.
-   X = 1*1.
-```
-
-The setting survives interactive `consult/1` and `use_module/1-2` program
-rebuilds. `answer_write_options` is a normal-mode host flag and is absent in
-strict ISO mode.
-
 ### Atomic-term operations and conversions
 
 | Predicate and principal call | Behavior |
@@ -6141,7 +6130,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)* and *spacing(standard or minimal)*. |
+| `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
@@ -6151,6 +6140,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 |
@@ -6228,7 +6223,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
 
@@ -6382,7 +6377,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
@@ -7786,8 +7783,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)` and `spacing(standard|minimal)` as explicitly
-  non-standard extensions, 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.