eyeprolog 1.2.40 → 1.2.42

package/package.json

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

package/src/cli.js

@@ -4,6 +4,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import process from 'node:process';
 import { goalsFromSource } from './goal-metadata.js';
+import { memoryStatistics } from './platform.js';
 
 let engineModule = null;
 let explanationModule = null;
@@ -230,9 +231,9 @@ async function runDefault(engine, program, options) {
   } catch (error) {
     if (error?.name !== 'HaltSignal') throw error;
     process.exitCode = error.code;
+  } finally {
+    if (options.stats) printStats(solver.stats);
   }
-
-  if (options.stats) printStats(solver.stats);
 }
 
 function writeExplanation(explanation, program, resolved, registry) {
@@ -259,7 +260,7 @@ Options:
   -h, --help            Show this help text and exit.
   -p, --proof           Enable proof explanations.
   -q, --quads           Run embedded quad tests and fail if any do not hold.
-  -s, --stats           Print solver statistics to stderr after execution.
+  -s, --stats           Print solver and memory statistics to stderr after execution.
   --iso-strict          Use ISO/IEC 13211-1 core + Corrigenda 1-3 only;
                         reject EyeProlog language extensions and disable automatic tabling.
   -v, --version         Show the package version and exit.
@@ -294,7 +295,7 @@ function printWarnings(program) {
 
 function printStats(stats) {
   process.stderr.write('eyeprolog stats:\n');
-  for (const [key, value] of Object.entries(stats)) {
+  for (const [key, value] of Object.entries({ ...stats, ...memoryStatistics() })) {
     process.stderr.write(`  ${key}: ${value}\n`);
   }
 }

package/src/iso.js

@@ -1074,9 +1074,16 @@ function* nlBuiltin({ solver, goal, env }) {
   yield env;
 }
 
-function* termTextCandidates(stream) {
+function activeCharConverter(solver) {
+  if (solver.prologFlags.get('char_conversion')?.value?.name !== 'on' || solver.charConversions.size === 0) {
+    return null;
+  }
+  return (character) => solver.charConversions.get(character) ?? character;
+}
+
+function* termTextCandidates(stream, solver) {
   const source = String(stream.content);
-  const lastBufferedNonLayout = lastNonLayoutIndex(source, stream.position);
+  const convert = activeCharConverter(solver);
   let quote = null, lineComment = false, blockComment = false;
   for (let i = stream.position; i < source.length; i++) {
     const ch = source[i], next = source[i + 1];
@@ -1106,12 +1113,7 @@ function* termTextCandidates(stream) {
       continue;
     }
     if (ch === "'" || ch === '"') { quote = ch; continue; }
-    if (ch === '.' && isTerminatingFullStop(source, i)) {
-      // A buffered stream exposes what follows the layout after this dot.  If
-      // the dot continues a graphic token and later non-layout input exists,
-      // it is part of that maximal token rather than an early end char.  The
-      // interactive reader makes the corresponding decision incrementally.
-      if (continuesGraphicToken(source, i) && lastBufferedNonLayout > i) continue;
+    if (isTerminatingFullStop(source, i, convert)) {
       yield { text: source.slice(stream.position, i + 1), end: i + 1 };
     }
   }
@@ -1223,7 +1225,7 @@ function readTermFromStream(stream, solver) {
   let requestedInteractiveTerm = false;
   while (true) {
     let sawCandidate = false;
-    for (const candidate of termTextCandidates(stream)) {
+    for (const candidate of termTextCandidates(stream, solver)) {
       sawCandidate = true;
       if (candidate.lexicalError) {
         stream.position = candidate.end;
@@ -1713,21 +1715,22 @@ function numberListBuiltin(kind) {
     const list = deref(goal.args[1], env);
     if (value.type === VAR && list.type === VAR) throw new PrologError('instantiation_error');
     const text = numberListText(list, env, kind, value.type === NUMBER);
-    const next = env.clone();
     if (value.type === NUMBER) {
       if (text != null) {
         const parsed = parseIsoNumber(text);
         if (parsed == null) throw numberSyntaxError;
-        if (sameNumber(value, parsed)) yield next;
+        if (sameNumber(value, parsed)) yield env.clone();
         return;
       }
       const items = characters(canonicalNumberText(value)).map((ch) =>
         kind === 'chars' ? atom(ch) : numberTerm(ch.codePointAt(0)));
+      const next = env.clone();
       if (unify(goal.args[1], listFromItems(items), next)) yield next;
       return;
     }
     const parsed = parseIsoNumber(text);
     if (parsed == null) throw numberSyntaxError;
+    const next = env.clone();
     if (unify(goal.args[0], parsed, next)) yield next;
   };
 }
@@ -1977,36 +1980,59 @@ function* phraseBuiltin({ solver, goal, env }) {
     solver.absorbStatsFrom(child);
   }
 }
-export function formalErrorTerm(error) {
-  const context = error.contextTerm ?? atom('eyeprolog');
-  if (error.formalTerm != null) return compound('error', [error.formalTerm, context]);
-  const parse = (text) => {
-    const open = text.indexOf('(');
-    if (open === -1) return atom(text);
-    const name = text.slice(0, open);
-    const inner = text.slice(open + 1, -1);
-    const args = [];
-    let start = 0;
-    let depth = 0;
-    for (let i = 0; i <= inner.length; i++) {
-      const ch = inner[i];
-      if (ch === '(') depth++;
-      else if (ch === ')') depth--;
-      else if ((ch === ',' || i === inner.length) && depth === 0) {
-        args.push(parse(inner.slice(start, i).trim()));
-        start = i + 1;
-      }
+const defaultErrorContext = atom('eyeprolog');
+
+function parseFormalErrorTerm(text) {
+  const open = text.indexOf('(');
+  if (open === -1) return atom(text);
+  const name = text.slice(0, open);
+  const inner = text.slice(open + 1, -1);
+  const args = [];
+  let start = 0;
+  let depth = 0;
+  for (let i = 0; i <= inner.length; i++) {
+    const ch = inner[i];
+    if (ch === '(') depth++;
+    else if (ch === ')') depth--;
+    else if ((ch === ',' || i === inner.length) && depth === 0) {
+      args.push(parseFormalErrorTerm(inner.slice(start, i).trim()));
+      start = i + 1;
     }
-    return compound(name, args);
-  };
-  let formal = parse(error.formal);
+  }
+  return compound(name, args);
+}
+
+function hasDefaultGroundErrorShape(error) {
+  return error.formalTerm == null && error.culprit == null && error.contextTerm == null;
+}
+
+export function formalErrorTerm(error) {
+  // Reused processor errors can occur hundreds of thousands of times in a
+  // caught failure loop. Cache their immutable ground error/2 term on the
+  // error object itself instead of rebuilding the same tree on every catch.
+  if (hasDefaultGroundErrorShape(error) && error._groundErrorTerm != null) {
+    return error._groundErrorTerm;
+  }
+
+  const context = error.contextTerm ?? defaultErrorContext;
+  let formal = error.formalTerm ?? parseFormalErrorTerm(error.formal);
   if (error.culprit != null) {
     if (formal.type === COMPOUND) formal = compound(formal.name, [...formal.args, error.culprit]);
     else if (formal.type === ATOM && formal.name === 'uninstantiation_error') {
       formal = compound(formal.name, [error.culprit]);
     }
   }
-  return compound('error', [formal, context]);
+  const term = compound('error', [formal, context]);
+  if (hasDefaultGroundErrorShape(error)) error._groundErrorTerm = term;
+  return term;
+}
+
+function prologErrorBall(error) {
+  const term = formalErrorTerm(error);
+  // Ground terms are immutable from unification's perspective: bindings are
+  // recorded only in the catcher Env, so copying them is unnecessary.
+  if (hasDefaultGroundErrorShape(error) || termIsGround(term)) return term;
+  return freshCopy(term, new Env());
 }
 function* catchBuiltin({ solver, goal, env }) {
   const child = solver.cloneForInnerGoal();
@@ -2018,7 +2044,7 @@ function* catchBuiltin({ solver, goal, env }) {
     const ball = error instanceof ThrownTerm
       ? error.term
       : error instanceof PrologError
-        ? freshCopy(formalErrorTerm(error), new Env())
+        ? prologErrorBall(error)
         : null;
     if (ball == null) throw error;
     const recovered = env.clone();

package/src/parser.js

@@ -378,10 +378,6 @@ class Parser {
     const line = this.line;
     const ch = this.peek();
     if (!ch) return { type: TOK.EOF, text: '', line };
-    if (this.source.startsWith('...', this.pos) && this.peek(3) !== '.') {
-      this.pos += 3;
-      return { type: TOK.ATOM, text: '...', line };
-    }
     if (ch === '?' && this.peek(1) === '-' &&
         !(isGraphicAtomCode(this.peek(2).charCodeAt(0)) && !this.terminatingFullStop(this.pos + 2))) {
       this.pos += 2;

package/src/platform.js

@@ -23,6 +23,13 @@ export function currentWorkingDirectory() {
   return isNode && typeof process.cwd === 'function' ? process.cwd() : '/';
 }
 
+function oldGenerationUsedSize() {
+  if (!isNode || typeof v8?.getHeapSpaceStatistics !== 'function') return null;
+  return v8.getHeapSpaceStatistics()
+    .filter(({ space_name: name }) => name !== 'read_only_space' && !name.startsWith('new_'))
+    .reduce((total, { space_used_size: size }) => total + size, 0);
+}
+
 export function usedHeapSize() {
   if (isNode && typeof process.memoryUsage === 'function') {
     // --max-old-space-size constrains V8's old generation, not the complete
@@ -30,11 +37,9 @@ export function usedHeapSize() {
     // with total heap use makes bursts of collectible new-space objects look
     // like retained memory. Measure the corresponding non-young spaces when
     // an old-space limit was supplied.
-    if (configuredOldSpaceLimit != null && typeof v8?.getHeapSpaceStatistics === 'function') {
-      const spaces = v8.getHeapSpaceStatistics();
-      return spaces
-        .filter(({ space_name: name }) => name !== 'read_only_space' && !name.startsWith('new_'))
-        .reduce((total, { space_used_size: size }) => total + size, 0);
+    if (configuredOldSpaceLimit != null) {
+      const oldGeneration = oldGenerationUsedSize();
+      if (oldGeneration != null) return oldGeneration;
     }
     return process.memoryUsage().heapUsed;
   }
@@ -42,6 +47,31 @@ export function usedHeapSize() {
   return Number.isFinite(memory?.usedJSHeapSize) ? memory.usedJSHeapSize : null;
 }
 
+export function memoryStatistics() {
+  const stats = {};
+  if (isNode && typeof process.memoryUsage === 'function') {
+    const memory = process.memoryUsage();
+    stats.memory_heap_used_bytes = memory.heapUsed;
+    const oldGeneration = oldGenerationUsedSize();
+    if (oldGeneration != null) stats.memory_old_generation_used_bytes = oldGeneration;
+    stats.memory_guard_used_bytes = configuredOldSpaceLimit != null && oldGeneration != null
+      ? oldGeneration
+      : memory.heapUsed;
+    stats.memory_rss_bytes = memory.rss;
+  } else {
+    const memory = globalThis.performance?.memory;
+    if (Number.isFinite(memory?.usedJSHeapSize)) {
+      stats.memory_heap_used_bytes = memory.usedJSHeapSize;
+      stats.memory_guard_used_bytes = memory.usedJSHeapSize;
+    }
+  }
+  const softLimit = softHeapLimit();
+  const hardLimit = hardHeapLimit();
+  if (Number.isFinite(softLimit)) stats.memory_soft_limit_bytes = softLimit;
+  if (Number.isFinite(hardLimit)) stats.memory_hard_limit_bytes = hardLimit;
+  return stats;
+}
+
 export function softHeapLimit() {
   const limit = hardHeapLimit();
   // Leave ample room for the generator stack to unwind and for the top level

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, isCompleteReadTermText } from './iso.js';
+import { formalErrorTerm } from './iso.js';
 import {
   characterCodeConstantEnd, continuesGraphicToken, isTerminatingFullStop, quotedEscapeEnd,
 } from './syntax-scan.js';
@@ -171,8 +171,8 @@ class LineReader {
       const line = this.readTerminalLineSync();
       if (line == null) return source.trim() ? source : null;
       source += `${line}\n`;
-      const end = terminalFullStop(source);
-      if (end >= 0 && acceptsReadTermBoundary(source, end, solver)) {
+      const end = terminalFullStop(source, solver);
+      if (end >= 0) {
         return source.slice(0, end + 1) + '\n';
       }
       prompt = '|    ';
@@ -300,7 +300,7 @@ async function prepareInteractiveTermInput(state, goal, reader) {
   // fallback for piped/non-TTY REPL tests and scripted input.
   if (reader.canReadTermSynchronously()) return;
   const stream = interactiveTermInputStream(state, goal);
-  if (stream == null || terminalFullStop(String(stream.content).slice(stream.position)) >= 0) return;
+  if (stream == null || terminalFullStop(String(stream.content).slice(stream.position), state.solver) >= 0) return;
 
   const text = await readInteractiveTerm(reader, state.solver);
   if (text == null) return;
@@ -343,24 +343,23 @@ async function readInteractiveTerm(reader, solver = null) {
     const line = await reader.read(prompt);
     if (line == null) return source.trim() ? source : null;
     source += `${line}\n`;
-    const end = terminalFullStop(source);
-    if (end >= 0 && acceptsReadTermBoundary(source, end, solver)) {
+    const end = terminalFullStop(source, solver);
+    if (end >= 0) {
       return source.slice(0, end + 1) + '\n';
     }
     prompt = '|    ';
   }
 }
 
-function acceptsReadTermBoundary(source, end, solver) {
-  // A dot after a graphic character has two possible readings.  Stop at once
-  // when the candidate is already a complete term (for example `./*.`);
-  // otherwise keep reading so a later end char can make it part of an atom
-  // (for example the first dot in `!,*.\n.`).
-  return !continuesGraphicToken(source, end) || solver == null ||
-    isCompleteReadTermText(source.slice(0, end + 1), solver);
+function activeCharConverter(solver) {
+  if (solver?.prologFlags.get('char_conversion')?.value?.name !== 'on' || solver.charConversions.size === 0) {
+    return null;
+  }
+  return (character) => solver.charConversions.get(character) ?? character;
 }
 
-function terminalFullStop(source) {
+function terminalFullStop(source, solver = null) {
+  const convert = activeCharConverter(solver);
   let quote = null;
   let lineComment = false;
   let blockComment = false;
@@ -415,7 +414,7 @@ function terminalFullStop(source) {
     }
     if ('([{'.includes(ch)) depth++;
     else if (')]}'.includes(ch)) depth = Math.max(0, depth - 1);
-    else if (ch === '.' && depth === 0 && isTerminatingFullStop(source, i) &&
+    else if (depth === 0 && isTerminatingFullStop(source, i, convert) &&
              onlyLayoutAndComments(source.slice(i + 1))) return i;
   }
   return -1;
@@ -503,11 +502,15 @@ async function solveQuery(engine, state, goal, reader, output) {
     if (formattingAfterAdvance) output.write(' ');
     formattingAfterAdvance = false;
     output.write(current.output);
-    output.write(`${firstAnswer ? ' ' : ''}${formatAnswer(engine, state, variables, current.result.value)}`);
+    const answer = formatAnswer(engine, state, variables, current.result.value);
+    output.write(`${firstAnswer ? ' ' : ''}${answer}`);
     answersShown++;
     firstAnswer = false;
     if (!next.error && next.result.done) {
-      output.write('.\n');
+      // A terminal full stop cannot immediately follow a graphic token: the
+      // scanner would absorb it into that token. Insert layout so the printed
+      // answer remains valid Prolog text (issue #44).
+      output.write(`${continuesGraphicToken(answer, answer.length) ? ' ' : ''}.\n`);
       return null;
     }
 

package/src/syntax-scan.js

@@ -4,21 +4,49 @@
 
 const graphicTokenCharacters = new Set('#$&*+-./<=>?@^~\\:');
 
-export function continuesGraphicToken(source, index) {
-  return index > 0 && graphicTokenCharacters.has(source[index - 1]);
+export function continuesGraphicToken(source, index, convert = null) {
+  if (index <= 0) return false;
+  const rawPrevious = source[index - 1];
+  const previous = convert == null ? rawPrevious : convert(rawPrevious);
+  // Most full stops follow a non-graphic token. Reject those in O(1) before
+  // doing the rarer character-code/comment disambiguation below; otherwise a
+  // large source with many term-ending dots degenerates into repeated backward
+  // scans (notably multi-megabyte generated data files).
+  if (!graphicTokenCharacters.has(previous)) return false;
+
+  // A graphic-looking character can be the payload or closing escape of a
+  // character-code constant rather than a graphic token.  For example, the
+  // backslash immediately before the full stop in `0'\x41\.` belongs to
+  // the number token, so that full stop still terminates the term.
+  const apostrophe = source.lastIndexOf("'", index - 1);
+  if (apostrophe >= 0 && characterCodeConstantEnd(source, apostrophe) === index - 1) return false;
+  // The slash that closes a bracketed comment is layout, not the tail of a
+  // graphic token. Distinguish it from spellings such as `//*.*/`, where the
+  // apparent /* is itself embedded in a graphic token and therefore never
+  // opens a comment.
+  if (source[index - 1] === '/' && source[index - 2] === '*') {
+    for (let open = source.lastIndexOf('/*', index - 3); open >= 0;
+         open = source.lastIndexOf('/*', open - 1)) {
+      if (open === 0 || !graphicTokenCharacters.has(source[open - 1])) return false;
+    }
+  }
+  return true;
 }
 
-export function isTerminatingFullStop(source, index) {
-  if (source[index] !== '.') return false;
-  const next = source[index + 1] ?? '';
-  // At a line boundary, after a single-line comment marker, or at end of
-  // input, the dot is the read-term end char. Before horizontal layout it is
-  // instead part of an already-started graphic token: `./*. .` is the atom
-  // `./*.` followed by its separate end char. A directly following /* also
-  // stays in the current graphic token; bracketed comments are recognized
-  // only when /* begins a token.
+export function isTerminatingFullStop(source, index, convert = null) {
+  const current = convert == null ? source[index] : convert(source[index]);
+  if (current !== '.') return false;
+  const rawNext = source[index + 1] ?? '';
+  const next = convert == null ? rawNext : convert(rawNext);
+  // A full stop cannot terminate a term when it can still extend the graphic
+  // token immediately before it. This remains true at a line boundary and at
+  // the current end of interactive input: `*.\n` is the graphic token `*.`
+  // followed by layout, so read/1 must keep waiting for a separate end char.
+  // Conversely `!.\n` terminates because ! is a solo token, not a graphic
+  // token character accepted by continuesGraphicToken().
+  if (continuesGraphicToken(source, index, convert)) return false;
   if (next === '' || next === '%' || next === '\n' || next === '\r') return true;
-  if (/^[\u0009\u000b\u000c\u0020]$/.test(next)) return !continuesGraphicToken(source, index);
+  if (/^[\u0009\u000b\u000c\u0020]$/.test(next)) return true;
   return false;
 }
 

package/src/write.js

@@ -4,8 +4,8 @@ import {
   Env, deref, isCons, isEmptyList,
 } from './term.js';
 
-const graphicAtomCharacters = new Set('!#$&*+-/<=>?@^~\\'.split(''));
-const dottedGraphicAtomCharacters = new Set([...graphicAtomCharacters, '.']);
+const graphicAtomCharacters = new Set('!#$&*+-./<=>?@^~\\'.split(''));
+const dottedGraphicAtomCharacters = graphicAtomCharacters;
 const compactInfixOperators = new Set([':', '..']);
 
 function quotedControlEscape(ch) {
@@ -28,7 +28,11 @@ function quotedControlEscape(ch) {
 function atomNeedsQuotes(name) {
   if (!name) return true;
   if (name === '[]' || name === '{}') return false;
-  if (name === '...') return false;
+  // A lone full stop is the end token, not a graphic atom.  Longer
+  // graphic tokens may contain dots and are valid unquoted writeq/1 output
+  // (WG17 #371-373: ./*, .*, ...*).  Only a token beginning with /* would
+  // be read as a bracketed comment and therefore still requires quoting.
+  if (name === '.') return true;
   if (name.startsWith('/*')) return true;
   if (/^[a-z][A-Za-z0-9_]*$/.test(name)) return false;
   for (const ch of name) if (!graphicAtomCharacters.has(ch)) return true;

package/test/conformance/expected-errors/rules/extra_rule_without_body.txt

@@ -1 +1 @@
-parse line 1: bad term
+parse line 1: expected ., got :-.

package/test/conformance/expected-errors/syntax/extra_double_period_rejected.txt

@@ -1 +1 @@
-parse line 1: expected ., got .
+parse line 1: expected ., got ..

package/test/conformance/wg17-syntax-cases.json

@@ -671,7 +671,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "'//*.*/'",
+            "output": "//*.*/",
             "variables": "[]"
           }
         ]
@@ -4302,7 +4302,7 @@
             "variables": "[]"
           },
           {
-            "output": ">('>.'(a),b)",
+            "output": ">(>.(a),b)",
             "variables": "[]"
           }
         ]
@@ -4322,7 +4322,7 @@
             "variables": "[]"
           },
           {
-            "output": "=('>.'(a),b)",
+            "output": "=(>.(a),b)",
             "variables": "[]"
           }
         ]
@@ -4342,7 +4342,7 @@
             "variables": "[]"
           },
           {
-            "output": "','('>.'(a),b)",
+            "output": "','(>.(a),b)",
             "variables": "[]"
           }
         ]
@@ -4362,7 +4362,7 @@
             "variables": "[]"
           },
           {
-            "output": "'>.'(a)",
+            "output": ">.(a)",
             "variables": "[]"
           }
         ]
@@ -5022,7 +5022,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "'.+'",
+            "output": ".+",
             "variables": "[]"
           }
         ]
@@ -5273,7 +5273,7 @@
             "variables": "[]"
           },
           {
-            "output": "'.>'('.>'(a))",
+            "output": ".>(.>(a))",
             "variables": "[]"
           }
         ]

package/test/run-regression.mjs

@@ -39,6 +39,7 @@ import {
   parseProgramText,
 } from '../src/index.js';
 import { ISO_OPERATOR_DEFINITIONS, parseGoalText, parseNumberTokenText } from '../src/parser.js';
+import { PrologError, formalErrorTerm } from '../src/iso.js';
 import { compareTerms } from '../src/term.js';
 import { formatTermForWrite } from '../src/write.js';
 import { selectClauseCandidates } from '../src/program.js';
@@ -102,6 +103,16 @@ export function runRegression(reporter = new TestReporter()) {
 
 function regressionCases() {
   return [
+    {
+      name: 'large source scanning avoids quadratic full-stop lookback',
+      run: () => {
+        const result = runCli(['examples/path-discovery.pl'], { timeout: 10000 });
+        if (result.error) throw new Error(`path-discovery timed out or failed to launch: ${result.error.message}`);
+        assertEqual(result.status, 0, `path-discovery status; stderr=${result.stderr}`);
+        assertIncludes(result.stdout, "airroute('Ostend-Bruges International Airport', 'Václav Havel Airport Prague'",
+          'path-discovery result');
+      },
+    },
     {
       name: '--proof rule fact explanation output',
       run: () => runWhy({
@@ -733,24 +744,77 @@ c4 ?- call((!;1)).
         assertIncludes(upstreamResult.stdout, '46 true.', 'WG17 #367 output');
       },
     },
+    {
+      name: 'top level separates terminal full stop from graphic answers (issue #44)',
+      run: () => {
+        const result = runCli([], { input: 'X = .* .\nhalt.\n' });
+        assertEqual(result.status, 0, 'issue #44 exit status');
+        assertIncludes(result.stdout, 'X = .* .\n', 'graphic binding is separated from terminal full stop');
+        assertNotIncludes(result.stdout, 'X = .*.\n', 'terminal full stop is not absorbed into graphic atom');
+        assertEqual(result.stderr, '', 'issue #44 stderr');
+      },
+    },
+    {
+      name: 'writeq leaves ISO dotted graphic atoms unquoted (WG17 #371-373)',
+      run: () => {
+        const result = runCli([], {
+          input: 'writeq(./*).\nwriteq(.*).\nwriteq(...*).\nhalt.\n',
+        });
+        assertEqual(result.status, 0, 'dotted graphic writeq exit status');
+        assertIncludes(result.stdout, '  ./* true.\n', 'writeq ./* is unquoted');
+        assertIncludes(result.stdout, '  .* true.\n', 'writeq .* is unquoted');
+        assertIncludes(result.stdout, '  ...* true.\n', 'writeq ...* is unquoted');
+        assertNotIncludes(result.stdout, "'./*'", 'writeq ./* has no quotes');
+        assertNotIncludes(result.stdout, "'.*'", 'writeq .* has no quotes');
+        assertNotIncludes(result.stdout, "'...*'", 'writeq ...* has no quotes');
+      },
+    },
     {
       name: 'readers distinguish graphic tokens, comments, and full stops (issue #41)',
       run: () => {
-        const parsed = parseProgramText('./*.');
+        const parsed = parseProgramText('./* .');
         assertEqual(parsed.length, 1, 'graphic atom clause count');
         assertEqual(parsed[0].head.name, './*', 'comment opener stays inside graphic atom');
 
+        // A dot immediately after a graphic token belongs to that maximal
+        // token. A separate end char is therefore required even at a line
+        // boundary; this is the waiting behavior called out in WG17 #370-373.
+        const waitProgram = Program.parse('');
+        const waitSolver = new Solver(waitProgram, {
+          registry: getEyePrologRegistry(),
+          ioOptions: { input: '*.\n' },
+        });
+        const waitStream = waitSolver.io.resolve('user_input');
+        let refillRequests = 0;
+        waitStream.interactiveReadTerm = () => {
+          refillRequests++;
+          return '.\n';
+        };
+        const waitGoal = parseGoalText('read(T)', {
+          operatorDefinitions: [...waitProgram.operators.values()],
+        });
+        const waitAnswers = [...waitSolver.solve([waitGoal], new Env(), 0)];
+        assertEqual(waitAnswers.length, 1, 'graphic token read answer after refill');
+        assertEqual(refillRequests, 1, 'graphic token boundary waits for a separate end char');
+        assertEqual(copyResolved(waitGoal.args[0], waitAnswers[0]).name, '*.', 'maximal graphic token after refill');
+
         const read = runEyeProlog('', {
           goal: 'read(T)',
-          ioOptions: { input: './*.' },
+          ioOptions: { input: './*. .' },
         });
-        assertEqual(read.stdout, "read('./*').\n", 'graphic atom writeq readback');
+        assertEqual(read.stdout, "read(./*.).\n", 'dotted graphic atom writeq readback');
+
+        const ellipsisGraphic = runEyeProlog('', {
+          goal: 'read(T)',
+          ioOptions: { input: '...*\n.\n' },
+        });
+        assertEqual(ellipsisGraphic.stdout, "read(...*).\n", 'ellipsis prefix remains inside maximal graphic atom');
 
         const consecutive = runEyeProlog('answer(A, B) :- read(A), read(B).\n', {
           goal: 'answer(A, B)',
           ioOptions: { input: './*. .\nok.\n' },
         });
-        assertEqual(consecutive.stdout, "answer('./*.', ok).\n", 'following read starts after the complete term');
+        assertEqual(consecutive.stdout, "answer(./*., ok).\n", 'following read starts after the complete term');
 
         // A possible full stop can fail to complete the term while still
         // extending a current graphic operator into an ordinary atom.  The
@@ -820,7 +884,7 @@ c4 ?- call((!;1)).
           input: 'read(T).\n./*. .\nread(T).\nok.\nread(T).\n!.!.\nhalt.\n',
         });
         assertEqual(repl.status, 0, 'REPL exit status');
-        assertIncludes(repl.stdout, 'T = ./*..', 'REPL dotted graphic atom answer');
+        assertIncludes(repl.stdout, 'T = ./*. .', 'REPL dotted graphic atom answer');
         assertNotIncludes(repl.stdout, "T = './*.'", 'REPL dotted graphic atom has no spurious quotes');
         assertIncludes(repl.stdout, 'T = ok.', 'REPL following read answer');
         assertIncludes(repl.stdout, 'error(syntax_error(read_term), eyeprolog)', 'REPL syntax error');
@@ -1562,10 +1626,10 @@ c4 ?- call((!;1)).
         if (available.status !== 0) return;
         const command = `${shellQuote(process.execPath)} ${shellQuote(bin)}`;
         const scriptCommand =
-          `{ printf 'read(X), read(Y).\n'; sleep 0.15; ` +
-          `printf 'foo.\n'; sleep 0.15; printf 'bar.\n'; sleep 0.15; ` +
-          `printf 'read(Z).\n'; sleep 0.15; printf '\\004'; sleep 0.15; ` +
-          `printf 'true.\n'; sleep 0.15; printf 'halt.\n'; } | ` +
+          `{ printf 'read(X), read(Y).\n'; sleep 0.3; ` +
+          `printf 'foo.\n'; sleep 0.3; printf 'bar.\n'; sleep 0.3; ` +
+          `printf 'read(Z).\n'; sleep 0.3; printf '\\004'; sleep 0.3; ` +
+          `printf 'true.\n'; sleep 0.3; printf 'halt.\n'; } | ` +
           `script -qefc ${shellQuote(command)} /dev/null`;
         const result = spawnSync('sh', ['-c', scriptCommand], {
           cwd: packageRoot,
@@ -1876,13 +1940,29 @@ c4 ?- call((!;1)).
 
 
     {
-      name: '--stats prints solver statistics to stderr',
+      name: '--stats prints solver and memory statistics to stderr',
       run: () => {
         const result = runCli(['--stats', '-'], { input: '%% goal: q(X, Y)\np(a, b).\nq(X, Y) :- p(X, Y).\n' });
         assertEqual(result.status, 0, 'exit status');
         assertEqual(result.stdout, 'q(a, b).\n', 'stdout');
         assertIncludes(result.stderr, 'eyeprolog stats:\n', 'stderr');
         assertIncludes(result.stderr, '  solve_goals_calls:', 'stderr');
+        assertIncludes(result.stderr, '  memory_heap_used_bytes:', 'stderr');
+        assertIncludes(result.stderr, '  memory_old_generation_used_bytes:', 'stderr');
+        assertIncludes(result.stderr, '  memory_guard_used_bytes:', 'stderr');
+        assertIncludes(result.stderr, '  memory_rss_bytes:', 'stderr');
+        assertIncludes(result.stderr, '  memory_soft_limit_bytes:', 'stderr');
+        assertIncludes(result.stderr, '  memory_hard_limit_bytes:', 'stderr');
+      },
+    },
+    {
+      name: '--stats is still printed when a query raises an error',
+      run: () => {
+        const result = runCli(['--stats', '-'], { input: "%% goal: number_chars(N, ['x'])\n" });
+        assertEqual(result.status, 1, 'exit status');
+        assertIncludes(result.stderr, 'eyeprolog stats:\n', 'stderr');
+        assertIncludes(result.stderr, '  memory_heap_used_bytes:', 'stderr');
+        assertIncludes(result.stderr, 'eyeprolog: error(syntax_error(number))', 'stderr');
       },
     },
     {
@@ -2896,6 +2976,15 @@ open(X) :- candidate(X), \\+ closed(X).
         assertEqual(result.stdout, '300000', 'fresh-variable answer count');
       },
     },
+    {
+      name: 'ground Prolog error terms are reused across catches',
+      run: () => {
+        const error = new PrologError('syntax_error(number)');
+        const first = formalErrorTerm(error);
+        const second = formalErrorTerm(error);
+        assertEqual(first === second, true, 'reused ground error term');
+      },
+    },
     {
       name: 'caught number syntax errors do not exhaust memory on distinct inputs',
       run: () => {
@@ -2916,22 +3005,22 @@ open(X) :- candidate(X), \\+ closed(X).
           const goal = parseGoalText('trial(Chars)');
           let count = 0;
           for (const _ of solver.solve([goal], new Env(), 0)) {
-            if (++count === 50000) break;
+            if (++count === 250000) break;
           }
-          if (count !== 50000) throw new Error('unexpected answer count: ' + count);
+          if (count !== 250000) throw new Error('unexpected answer count: ' + count);
           process.stdout.write(String(count));
         `;
         const result = spawnSync(process.execPath, [
-          // A smaller heap preserves the original false-exhaustion signal
-          // without requiring half a million transient conversion attempts.
+          // Run well past the roughly 126,000-answer failure reported in #28
+          // while keeping the host heap deliberately constrained.
           '--max-old-space-size=32',
           '--input-type=module',
           '--eval',
           script,
-        ], { cwd: packageRoot, encoding: 'utf8', timeout: 10000 });
+        ], { 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, '50000', 'distinct number syntax attempts');
+        assertEqual(result.stdout, '250000', 'distinct number syntax attempts');
       },
     },
     {
@@ -4369,6 +4458,7 @@ function runCli(args, options = {}) {
     encoding: 'utf8',
     env: options.env ? { ...process.env, ...options.env } : process.env,
     input: options.input ?? undefined,
+    timeout: options.timeout ?? undefined,
   });
 }
 

package/the-art-of-eyeprolog.md

@@ -4633,7 +4633,11 @@ testing is a powerful guard during program transformation.
 `--stats` reports work, not meaning. A high solution count may be necessary or
 may indicate a generator that should be constrained. Many table hits may show
 effective reuse; many distinct table entries may reveal an argument that
-prevents calls from sharing.
+prevents calls from sharing. On the Node CLI it also reports current heap use,
+non-young/old-generation use, the amount currently compared with the memory
+guard, resident-set size, and the soft and hard memory ceilings in bytes. These memory figures are printed even when execution ends by
+raising a Prolog error, which makes `--stats` useful when reproducing bounded
+memory failures such as long-running conversion stress tests.
 
 Compare statistics only between runs with the same query, data, and observable
 answer contract. A faster program that silently loses answers is not an
@@ -5253,10 +5257,12 @@ write_event(Path, Event) :-
 
 The period is essential when another Prolog processor will read the result as
 a term. `write/1-2` uses readable conventional syntax, `writeq/1-2` quotes
-where needed, and `write_canonical/1-2` exposes canonical structure. ISO term
-output uses only the separator characters needed by the syntax, so functional
-arguments and list elements are emitted compactly; for example `writeq([a,b])`
-outputs `[a,b]`.
+where needed, and `write_canonical/1-2` exposes canonical structure. Dotted
+graphic atoms do not need quotes merely because they contain a period:
+`writeq(./*)`, `writeq(.*)`, and `writeq(...*)` output `./*`, `.*`, and `...*`
+respectively. ISO term output uses only the separator characters needed by the
+syntax, so functional arguments and list elements are emitted compactly; for
+example `writeq([a,b])` outputs `[a,b]`.
 `write_term/2-3` supports `quoted/1`, `ignore_ops/1`, `numbervars/1`, and
 `variable_names/1`.
 
@@ -5377,10 +5383,12 @@ quote an atom whose name itself contains a colon. Unquoted angle-bracket IRIs
 are not syntax.
 
 A `/*` sequence opens a block comment only when it begins a token; inside a
-maximal graphic token the slash and star remain atom characters. A period ends
-a term only when it is recognized as the terminating full stop. Consequently,
-`./*.` at the end of a line reads the atom `./*`, whereas `./*. .` reads the
-atom `./*.` and consumes the second period as the terminator.
+maximal graphic token the slash and star remain atom characters. Graphic tokens
+are formed maximally before a period can be recognized as the terminating full
+stop. Consequently, interactive input `*.` or `./*.` is not yet a complete term:
+the period is part of the graphic atom and the reader waits for a separate
+terminating full stop. Thus `./*. .` reads the atom `./*.` and consumes the
+second period as the terminator.
 
 In the grammar below, `{ x }` means zero or more repetitions of `x`, `[ x ]`
 means that `x` is optional, and parentheses group alternatives. These marks
@@ -6344,8 +6352,10 @@ period-terminated query with no solutions prints `false.`; a solution without
 visible variable bindings prints `true.`. Answer substitutions are rendered as
 valid Prolog syntax under the current operator table: when a bound value would
 not be a valid right operand of the displayed `=/2`, EyeProlog adds parentheses,
-for example `T = (a = b).` rather than the invalid `T = a = b.`. Use `[file].`
-or `['file.pl'].` to
+for example `T = (a = b).` rather than the invalid `T = a = b.`. When an answer
+ends in a graphic token, the top level inserts layout before its terminating
+full stop so the two tokens cannot merge; for example `?- X = .* .` displays
+`X = .* .`, not `X = .*.`. Use `[file].` or `['file.pl'].` to
 consult local source, and `halt.` or `halt(Status).` to leave the top level.
 When `read/1-2` or `read_term/2-3` actually reaches interactive
 `user_input`, the top level requests the next full-stop-terminated Prolog term