eyeprolog 1.3.84 → 1.3.85

package/package.json

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

@@ -1555,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,
@@ -1720,6 +1738,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 +1787,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));
     }

package/src/solver.js

@@ -1495,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 ||
@@ -1613,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

@@ -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: () => {
@@ -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: () => {
@@ -3884,6 +4030,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 +4049,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 +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([]).
@@ -5197,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`.
 
@@ -5427,9 +5429,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 +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)*. |
+| `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 +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 |
@@ -6209,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
 
@@ -6363,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
@@ -7767,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)` 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.