eyeprolog 1.3.40 → 1.3.41

package/examples/book/README.md

@@ -249,3 +249,4 @@ npm run generate
 
 - [01-color.pl](chapter-40/01-color.pl) — Embedded quad tests
 - [02-program.pl](chapter-40/02-program.pl)
+- [03-program-2.pl](chapter-40/03-program-2.pl)

package/examples/book/chapter-40/02-program.pl

@@ -1,5 +1,5 @@
 % From The Art of EyeProlog, Chapter 40.
-inf :- inf, inf.
-
-?- inf.
-   loops.
+?- read(X).
+   inputs("1."), X = 1, unexpected.
+   inputs("1."), peeks(" "), X = 1.
+   inputs("1. "), peeks(" "), X = 1, unexpected.

package/examples/book/chapter-40/03-program-2.pl

@@ -0,0 +1,5 @@
+% From The Art of EyeProlog, Chapter 40.
+inf :- inf, inf.
+
+?- inf.
+   loops.

package/package.json

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

package/src/io.js

@@ -1,7 +1,7 @@
 // Synchronous ISO stream state shared by a solver and all of its inner solvers.
 import { BufferCtor, fs } from './platform.js';
 
-const INVALID_UTF8_SENTINEL = '\udc00';
+export const INVALID_UTF8_SENTINEL = '\udc00';
 
 export class InvalidCharacterEncodingError extends Error {
   constructor() {

package/src/iso.js

@@ -12,6 +12,7 @@ import {
 } from './parser.js';
 import { formatTermForWrite } from './write.js';
 import { emptyTerminalSequence, expandDcgBody, isListOrPartialList, validateDcgEmbeddedGoals } from './dcg.js';
+import { INVALID_UTF8_SENTINEL } from './io.js';
 import {
   characterCodeConstantEnd, continuesGraphicToken, isTerminatingFullStop, quotedEscapeEnd,
 } from './syntax-scan.js';
@@ -1089,6 +1090,13 @@ function* termTextCandidates(stream, 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];
+    // Text streams preserve invalid UTF-8 bytes as an impossible Unicode
+    // sentinel.  read/1-2 and read_term/2-3 must surface the same character
+    // representation error as get_char/1-2 instead of misclassifying the
+    // undecodable byte as malformed Prolog syntax (issue #64).
+    if (stream.strictUtf8 && ch === INVALID_UTF8_SENTINEL) {
+      throw new PrologError('representation_error(character)');
+    }
     if (lineComment) { if (ch === '\n') lineComment = false; continue; }
     if (blockComment) { if (ch === '*' && next === '/') { blockComment = false; i++; } continue; }
     if (quote) {
@@ -1305,10 +1313,10 @@ function* readTermBuiltin({ solver, goal, env }) {
   yield next;
 }
 function defaultTermWriteOptions(mode) {
-  if (mode === 'writeq') return { quoted: true, ignoreOps: false, numbervars: true, variableNames: new Map(), compact: true, operatorAtomsAsArgs: true, doubleQuotes: null };
-  if (mode === 'canonical') return { quoted: true, ignoreOps: true, numbervars: false, variableNames: new Map(), compact: true, operatorAtomsAsArgs: true, doubleQuotes: null };
-  if (mode === 'write_term') return { quoted: false, ignoreOps: false, numbervars: false, variableNames: new Map(), compact: true, operatorAtomsAsArgs: true, doubleQuotes: null };
-  return { quoted: false, ignoreOps: false, numbervars: true, variableNames: new Map(), compact: true, operatorAtomsAsArgs: true, doubleQuotes: null };
+  if (mode === 'writeq') return { quoted: true, ignoreOps: false, numbervars: true, variableNames: new Map(), compact: true, minimalOperatorSpacing: true, operatorAtomsAsArgs: true, doubleQuotes: null };
+  if (mode === 'canonical') return { quoted: true, ignoreOps: true, numbervars: false, variableNames: new Map(), compact: true, minimalOperatorSpacing: true, operatorAtomsAsArgs: true, doubleQuotes: null };
+  if (mode === 'write_term') return { quoted: false, ignoreOps: false, numbervars: false, variableNames: new Map(), compact: true, minimalOperatorSpacing: true, operatorAtomsAsArgs: true, doubleQuotes: null };
+  return { quoted: false, ignoreOps: false, numbervars: true, variableNames: new Map(), compact: true, minimalOperatorSpacing: true, operatorAtomsAsArgs: true, doubleQuotes: null };
 }
 
 function writeOptionBoolean(value, env, option) {

package/src/quads.js

@@ -11,6 +11,7 @@ import { Program } from './program.js';
 import { Solver } from './solver.js';
 import { getEyePrologRegistry } from './standard-library.js';
 import { formatTermForWrite } from './write.js';
+import { INVALID_UTF8_SENTINEL } from './io.js';
 
 const DEFAULT_QUAD_MAX_INFERENCES = 100000;
 const DEFAULT_LOOP_MAX_INFERENCES = 10000;
@@ -93,18 +94,24 @@ function checkAlternative(program, quad, alternative, options, context) {
     return { ok: false, kind: 'unsupported', expected: unsupported };
   }
 
-  const inputSpecs = [...new Set(leaves.filter((leaf) => leaf.input != null).map((leaf) => leaf.input))];
-  if (inputSpecs.length > 1) return { ok: false, kind: 'malformed', expected: alternative };
-  const input = inputSpecs[0] ?? '';
-  if (inputSpecs.length > 0 && leaves.length !== 1) return { ok: false };
+  const ioLeaves = leaves.filter((leaf) => leaf.input != null || leaf.peek != null);
+  if (ioLeaves.length > 1 || (ioLeaves.length > 0 && leaves.length !== 1)) {
+    return { ok: false, kind: 'malformed', expected: alternative };
+  }
+  const hasInputSpec = ioLeaves.length === 1;
+  const inputLeaf = ioLeaves[0] ?? null;
+  const input = inputLeaf?.input ?? '';
+  const peek = inputLeaf?.peek ?? null;
   const moreAt = leaves.findIndex((leaf) => leaf.more);
   const describedCount = moreAt < 0 ? leaves.length : moreAt + (leaves[moreAt].hasExpectation ? 1 : 0);
-  const maxSolutions = inputSpecs.length > 0
+  const maxSolutions = hasInputSpec
     ? 1
     : moreAt < 0 ? describedCount + 1 : Math.max(describedCount, 1);
   const actual = executeQuery(program, quad.query, input, maxSolutions, {
     ...options,
     detectLoops: leaves.some((leaf) => leaf.loops),
+    inputBoundary: hasInputSpec,
+    inputPeek: peek,
   });
 
   if (requiresSto) {
@@ -119,9 +126,12 @@ function checkAlternative(program, quad, alternative, options, context) {
     return { ok: true };
   }
 
-  if (inputSpecs.length > 0) {
+  if (hasInputSpec) {
     const leaf = leaves[0];
-    const matches = actual.inputPosition === input.length && matchLeaf(program, quad.query, leaf, actual, 0);
+    const exactConsumption = actual.inputPosition === input.length;
+    const expectedRemainder = `${peek ?? ''}${INVALID_UTF8_SENTINEL}`;
+    const boundaryPreserved = actual.inputRemainder === expectedRemainder;
+    const matches = exactConsumption && boundaryPreserved && matchLeaf(program, quad.query, leaf, actual, 0);
     if (actual.undecided && !matches) return undecidedResult(actual, alternative);
     return { ok: leaf.unexpected ? !matches : matches };
   }
@@ -147,14 +157,14 @@ function checkAlternative(program, quad, alternative, options, context) {
     // turn a successful negative match back into a failure.
     if (leaf.unexpected && leaf.error != null) return { ok: true };
     if (leaf.more) return { ok: true };
-    if (!leaf.unexpected && (leaf.false || leaf.error != null)) {
+    if (!leaf.unexpected && (leaf.false || leaf.loops || leaf.error != null)) {
       if (actual.undecided) return undecidedResult(actual, alternative);
       return { ok: position === leaves.length - 1 };
     }
     position++;
   }
 
-  const ended = position >= actual.solutions.length && actual.error == null && !actual.undecided;
+  const ended = position >= actual.solutions.length && actual.error == null && !actual.undecided && !actual.loopObserved;
   if (!ended && actual.undecided && position >= actual.solutions.length && actual.error == null) {
     return undecidedResult(actual, alternative);
   }
@@ -191,6 +201,7 @@ function describeLeaf(term) {
     loops: false,
     error: null,
     input: null,
+    peek: null,
     output: null,
     unsupported: null,
     malformed: null,
@@ -227,7 +238,9 @@ function describeLeaf(term) {
       continue;
     }
     if (item.type === COMPOUND && item.name === 'peeks' && item.arity === 1) {
-      leaf.unsupported ??= item;
+      const text = characterText(item.args[0]);
+      if (text == null || Array.from(text).length !== 1 || leaf.peek != null) leaf.malformed ??= item;
+      else leaf.peek = text;
       continue;
     }
     if (isErrorDescription(item)) leaf.error = item;
@@ -241,6 +254,9 @@ function describeLeaf(term) {
 
 function executeQuery(program, query, input, maxSolutions, options) {
   let pendingOutput = '';
+  const boundedInput = options.inputBoundary
+    ? `${input}${options.inputPeek ?? ''}${INVALID_UTF8_SENTINEL}`
+    : input;
   const solver = new Solver(program, {
     ...options,
     registry: options.registry ?? getEyePrologRegistry(),
@@ -254,10 +270,18 @@ function executeQuery(program, query, input, maxSolutions, options) {
     // allowance.
     solutionLimit: Math.max(maxSolutions, options.solutionLimit ?? 10000000),
     ioOptions: {
-      input,
+      input: boundedInput,
       write: (text) => { pendingOutput += String(text); },
     },
   });
+  if (options.inputBoundary) {
+    // Quads need a boundary that is neither EOF nor a valid character.  This
+    // mirrors Trealla's sentinel technique: inputs/1 says exactly what was
+    // consumed, while peeks/1 supplies one additional character that must
+    // remain unread.  If the query asks for anything beyond that boundary it
+    // sees representation_error(character), not an artificial EOF.
+    solver.io.resolve('user_input').strictUtf8 = true;
+  }
   // Undefined predicates are test failures rather than silent negative
   // answers unless the source explicitly selected another unknown policy.
   if (!(program.prologFlagDirectives ?? []).some(([flag]) => flag.type === ATOM && flag.name === 'unknown')) {
@@ -273,7 +297,15 @@ function executeQuery(program, query, input, maxSolutions, options) {
     iterator = solver.solve([query], new Env(), 0);
     while (solutions.length < maxSolutions) {
       pendingOutput = '';
+      const cycleBefore = solver.recursionCycleDetected;
       const result = iterator.next();
+      if (!cycleBefore && solver.recursionCycleDetected) {
+        // The recursion guard found an operational loop wall while advancing
+        // to this result.  Any answer produced only after that guard pruned the
+        // looping branch is not reachable by ordinary Prolog search, so do not
+        // count it as a leaf answer (issue #58 comment 5381101420).
+        break;
+      }
       if (result.done) {
         tailOutput += pendingOutput;
         complete = true;
@@ -289,22 +321,30 @@ function executeQuery(program, query, input, maxSolutions, options) {
   } finally {
     if (!complete) iterator?.return?.();
   }
-  const inputPosition = solver.io.resolve('user_input')?.position ?? 0;
+  const inputStream = solver.io.resolve('user_input');
+  const inputPosition = inputStream?.position ?? 0;
+  const inputRemainder = String(inputStream?.content ?? '').slice(inputPosition);
   const bounded = solver.depthLimitExceeded || solver.inferenceLimitExceeded;
-  const undecided = !options.detectLoops && (solver.recursionCycleDetected || bounded);
+  const loopObserved = solver.recursionCycleDetected;
+  // A structural recursion-cycle witness is stronger than a resource limit:
+  // it establishes an operational loop wall and can therefore refute a finite
+  // answer description.  Pure depth/inference exhaustion remains undecided.
+  const undecided = !options.detectLoops && !loopObserved && bounded;
   return {
     solutions,
     error,
     tailOutput,
     inputPosition,
+    inputRemainder,
     complete,
+    loopObserved,
     stoObserved: solver.occursCheckObserved,
-    nstoObserved: complete && !solver.occursCheckObserved && !solver.recursionCycleDetected &&
+    nstoObserved: complete && !solver.occursCheckObserved && !loopObserved &&
       !bounded && !resourceInterrupted,
     // A loops expectation explicitly asks for bounded nontermination evidence.
     // Other descriptions treat the same exhausted search budget as undecided:
     // a timeout cannot establish finite failure or an exact answer sequence.
-    loops: options.detectLoops && (solver.recursionCycleDetected || bounded),
+    loops: options.detectLoops && (loopObserved || bounded),
     undecided,
     undecidedReason: solver.inferenceLimitExceeded ? 'inference limit reached'
       : solver.depthLimitExceeded ? 'depth limit reached'
@@ -316,7 +356,7 @@ function executeQuery(program, query, input, maxSolutions, options) {
 function matchLeaf(program, query, leaf, actual, position) {
   if (leaf.loops) return actual.loops;
   if (leaf.false) {
-    return position >= actual.solutions.length && actual.error == null && !actual.undecided &&
+    return position >= actual.solutions.length && actual.error == null && !actual.undecided && !actual.loopObserved &&
       outputMatches(program, leaf.output, actual.tailOutput);
   }
   if (leaf.error != null) {

package/src/write.js

@@ -58,6 +58,51 @@ function isDottedGraphicAtom(name) {
     [...name].every((ch) => dottedGraphicAtomCharacters.has(ch));
 }
 
+function compactBoundaryNeedsSpace(left, right) {
+  const leftChars = Array.from(left);
+  const rightChars = Array.from(right);
+  const a = leftChars[leftChars.length - 1] ?? '';
+  const b = rightChars[0] ?? '';
+  if (!a || !b) return false;
+  // Adjacent quoted atoms need layout: `''` is part of quoted-atom syntax,
+  // so concatenating two quoted operator/argument tokens would change the
+  // tokenization (WG17 #169).
+  if (a === "'" && b === "'") return true;
+  // Adjacent graphic characters form one maximal graphic token. Keep them
+  // apart when an operator boundary would otherwise disappear (`a+ -b`,
+  // `a/ *b`, etc.).
+  if (graphicAtomCharacters.has(a) && graphicAtomCharacters.has(b)) return true;
+  // Alphanumeric operator names similarly need a lexical boundary from a
+  // neighbouring identifier/number token.  Most predefined word operators
+  // are handled explicitly below; this also protects quoted/custom cases that
+  // render without punctuation.
+  if (/^[A-Za-z0-9_]$/.test(a) && /^[A-Za-z0-9_]$/.test(b)) return true;
+  return false;
+}
+
+function isWordOperatorToken(token) {
+  return /^[a-z][A-Za-z0-9_]*$/.test(token);
+}
+
+function compactPrefixOperator(token, argument) {
+  if (isWordOperatorToken(token)) return `${token} ${argument}`;
+  return `${token}${compactBoundaryNeedsSpace(token, argument) ? ' ' : ''}${argument}`;
+}
+
+function compactPostfixOperator(argument, token) {
+  if (isWordOperatorToken(token)) return `${argument} ${token}`;
+  return `${argument}${compactBoundaryNeedsSpace(argument, token) ? ' ' : ''}${token}`;
+}
+
+function compactInfixOperator(left, token, right) {
+  // Solo punctuation operators already delimit themselves.
+  if (token === ',' || token === ';') return `${left}${token}${right}`;
+  if (isWordOperatorToken(token)) return `${left} ${token} ${right}`;
+  const before = compactBoundaryNeedsSpace(left, token) ? ' ' : '';
+  const after = compactBoundaryNeedsSpace(token, right) ? ' ' : '';
+  return `${left}${before}${token}${after}${right}`;
+}
+
 function legacyVariableToIso(name) {
   if (name === '?') return '_';
   const tail = name.slice(1);
@@ -313,9 +358,11 @@ function format(term, env, options, table, maxPriority = 1200, context = 'term')
         // numeric-leading argument so writeq/write_term remain read-back safe
         // (WG17 #135, #183, #215, #216, and #248).
         if (resolved.name === '-' && startsWithUnsignedNumber(resolved.args[0], env, table, options)) {
-          text = `${token} (${format(resolved.args[0], env, options, table, 1200)})`;
+          const argument = format(resolved.args[0], env, options, table, 1200);
+          text = options.minimalOperatorSpacing ? `${token}(${argument})` : `${token} (${argument})`;
         } else {
-          text = `${token} ${format(resolved.args[0], env, options, table, argumentPriority)}`;
+          const argument = format(resolved.args[0], env, options, table, argumentPriority);
+          text = options.minimalOperatorSpacing ? compactPrefixOperator(token, argument) : `${token} ${argument}`;
         }
       } else if (specifier === 'xf' || specifier === 'yf') {
         let argumentPriority = specifier === 'xf' ? priority - 1 : priority;
@@ -324,7 +371,8 @@ function format(term, env, options, table, maxPriority = 1200, context = 'term')
             ['fx', 'fy', 'xfx', 'xfy', 'yfx'].includes(childDefinition.specifier)) {
           argumentPriority = priority - 1;
         }
-        text = `${format(resolved.args[0], env, options, table, argumentPriority)} ${token}`;
+        const argument = format(resolved.args[0], env, options, table, argumentPriority);
+        text = options.minimalOperatorSpacing ? compactPostfixOperator(argument, token) : `${argument} ${token}`;
       } else {
         let leftPriority = specifier === 'yfx' ? priority : priority - 1;
         const rightPriority = specifier === 'xfy' ? priority : priority - 1;
@@ -334,9 +382,13 @@ function format(term, env, options, table, maxPriority = 1200, context = 'term')
         }
         const left = format(resolved.args[0], env, options, table, leftPriority);
         const right = format(resolved.args[1], env, options, table, rightPriority);
-        text = resolved.name === ',' ? `${left}, ${right}`
-          : compactInfixOperators.has(resolved.name) ? `${left}${token}${right}`
-            : `${left} ${token} ${right}`;
+        if (options.minimalOperatorSpacing) {
+          text = resolved.name === ',' ? `${left},${right}` : compactInfixOperator(left, token, right);
+        } else if (resolved.name === ',') {
+          text = `${left}, ${right}`;
+        } else {
+          text = compactInfixOperators.has(resolved.name) ? `${left}${token}${right}` : `${left} ${token} ${right}`;
+        }
       }
       return priority > maxPriority ? `(${text})` : text;
     }
@@ -358,6 +410,7 @@ export function formatTermForWrite(term, env = new Env(), options = {}) {
       ? printableGeneratedVariableNames(term, env, explicitVariableNames, options.variableNameState)
       : printableReadVariableNames(term, env, explicitVariableNames),
     compact: options.compact === true,
+    minimalOperatorSpacing: options.minimalOperatorSpacing === true,
     operatorAtomsAsArgs: options.operatorAtomsAsArgs === true,
     dottedGraphicAtoms: options.dottedGraphicAtoms === true,
   };

package/test/conformance/WG17-SYNTAX-STATUS.md

@@ -21,8 +21,8 @@ upstream assertion.
 The matrix runs in strict ISO stream-reader mode as part of `npm test`. The
 3 upstream `waits` cases are checked through EyeProlog's interactive input
 hook. All 366 executable cases are independently checked against the
-upstream Codex expectation. 365 cases additionally retain exact reviewed
-outcomes for stronger regression checking; 1 case currently relies on the upstream assertion alone.
+upstream Codex expectation. 366 cases additionally retain exact reviewed
+outcomes for stronger regression checking; 0 cases currently rely on the upstream assertion alone.
 
 ## Traceable evidence
 

package/test/conformance/expected/iso/wg17_syntax_high_risk.pl

@@ -6,8 +6,8 @@ wg17_hex_escape.
 f(*)
 f(;,'|',';;')
 wg17_operator_arguments.
-a * (b + c)
-a :- b, c
+a*(b+c)
+a:-b,c
 wg17_operator_precedence.
 wg17_spaced_prefix_operator((a, b)).
 '.'(a,[])

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

@@ -479,7 +479,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "(-) - (-)",
+            "output": "(-)-(-)",
             "variables": "[]"
           }
         ]
@@ -495,7 +495,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "(:-) :- (:-)",
+            "output": "(:-):-(:-)",
             "variables": "[]"
           }
         ]
@@ -511,7 +511,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "(*) = (*)",
+            "output": "(*)=(*)",
             "variables": "[]"
           }
         ]
@@ -559,7 +559,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "a * (b + c)",
+            "output": "a*(b+c)",
             "variables": "[]"
           }
         ]
@@ -607,7 +607,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "a :- b, c",
+            "output": "a:-b,c",
             "variables": "[]"
           }
         ]
@@ -862,7 +862,7 @@
           },
           {
             "output": "",
-            "variables": "['F' = ('.'),'A' = 2]"
+            "variables": "['F'=('.'),'A'=2]"
           }
         ]
       }
@@ -1015,7 +1015,7 @@
           },
           {
             "output": "",
-            "variables": "['X' = 1.2,'Y' = 3]"
+            "variables": "['X'=1.2,'Y'=3]"
           }
         ]
       }
@@ -1308,7 +1308,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "- (1)",
+            "output": "-(1)",
             "variables": "[]"
           }
         ]
@@ -1340,7 +1340,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "- (1 ^ 2)",
+            "output": "-(1^2)",
             "variables": "[]"
           }
         ]
@@ -1356,7 +1356,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "- a ^ 2",
+            "output": "-a^2",
             "variables": "[]"
           }
         ]
@@ -1372,7 +1372,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "- (a, b)",
+            "output": "-(a,b)",
             "variables": "[]"
           }
         ]
@@ -1388,7 +1388,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "- (1 * 2)",
+            "output": "-(1*2)",
             "variables": "[]"
           }
         ]
@@ -1404,7 +1404,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "- a",
+            "output": "-a",
             "variables": "[]"
           }
         ]
@@ -1420,7 +1420,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "- (-)",
+            "output": "-(-)",
             "variables": "[]"
           }
         ]
@@ -1436,7 +1436,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "- [-]",
+            "output": "-[-]",
             "variables": "[]"
           }
         ]
@@ -1452,7 +1452,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "- p(c)",
+            "output": "-p(c)",
             "variables": "[]"
           }
         ]
@@ -1468,7 +1468,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "- {}",
+            "output": "-{}",
             "variables": "[]"
           }
         ]
@@ -1484,7 +1484,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "- {a}",
+            "output": "-{a}",
             "variables": "[]"
           }
         ]
@@ -1500,7 +1500,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "- - a",
+            "output": "- -a",
             "variables": "[]"
           }
         ]
@@ -1516,7 +1516,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "- - - a",
+            "output": "- - -a",
             "variables": "[]"
           }
         ]
@@ -1532,7 +1532,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "- - (1)",
+            "output": "- -(1)",
             "variables": "[]"
           }
         ]
@@ -1552,7 +1552,7 @@
             "variables": "[]"
           },
           {
-            "output": "- (1 ~ 2 ~ 3)",
+            "output": "-(1~2~3)",
             "variables": "[]"
           }
         ]
@@ -1572,7 +1572,7 @@
             "variables": "[]"
           },
           {
-            "output": "- (1 ~ 2)",
+            "output": "-(1~2)",
             "variables": "[]"
           }
         ]
@@ -1592,7 +1592,7 @@
             "variables": "[]"
           },
           {
-            "output": "1 ~ 2",
+            "output": "1~2",
             "variables": "[]"
           }
         ]
@@ -1608,7 +1608,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "- [1]",
+            "output": "-[1]",
             "variables": "[]"
           }
         ]
@@ -1624,7 +1624,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "- A",
+            "output": "-A",
             "variables": "[]"
           }
         ]
@@ -1640,7 +1640,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "- A",
+            "output": "-A",
             "variables": "[]"
           },
           {
@@ -1660,11 +1660,11 @@
         "type": "success",
         "stages": [
           {
-            "output": "- A",
+            "output": "-A",
             "variables": "[]"
           },
           {
-            "output": "-1 '$VAR'",
+            "output": "-1'$VAR'",
             "variables": "[]"
           }
         ]
@@ -1685,7 +1685,7 @@
           },
           {
             "output": "",
-            "variables": "['X' = -1]"
+            "variables": "['X'= -1]"
           }
         ]
       }
@@ -1732,7 +1732,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "+ 1 ^ 2",
+            "output": "+1^2",
             "variables": "[]"
           }
         ]
@@ -1759,7 +1759,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "[+ {a},+ []]",
+            "output": "[+{a},+[]]",
             "variables": "[]"
           }
         ]
@@ -1840,7 +1840,7 @@
           },
           {
             "output": "",
-            "variables": "['X' = [a|b]]"
+            "variables": "['X'=[a|b]]"
           }
         ]
       }
@@ -2165,7 +2165,7 @@
         "stages": [
           {
             "output": "",
-            "variables": "['X' = 1]"
+            "variables": "['X'=1]"
           }
         ]
       }
@@ -2246,7 +2246,7 @@
         "stages": [
           {
             "output": "",
-            "variables": "['X' = a141]"
+            "variables": "['X'=a141]"
           }
         ]
       }
@@ -2467,7 +2467,7 @@
           },
           {
             "output": "",
-            "variables": "['X' = 0]"
+            "variables": "['X'=0]"
           }
         ]
       }
@@ -2486,7 +2486,7 @@
             "variables": "[]"
           },
           {
-            "output": "0 ''",
+            "output": "0''",
             "variables": "[]"
           }
         ]
@@ -2506,7 +2506,7 @@
             "variables": "[]"
           },
           {
-            "output": "0 ''",
+            "output": "0''",
             "variables": "[]"
           }
         ]
@@ -2543,7 +2543,7 @@
           },
           {
             "output": "",
-            "variables": "['F' = (''),'A' = 2]"
+            "variables": "['F'=(''),'A'=2]"
           }
         ]
       }
@@ -2563,7 +2563,7 @@
           },
           {
             "output": "",
-            "variables": "['F' = (''),'A' = 2]"
+            "variables": "['F'=(''),'A'=2]"
           }
         ]
       }
@@ -2653,7 +2653,7 @@
             "variables": "[]"
           },
           {
-            "output": "0 'f '",
+            "output": "0'f '",
             "variables": "[]"
           }
         ]
@@ -2685,7 +2685,7 @@
           },
           {
             "output": "",
-            "variables": "['F' = ('1'),'A' = 2]"
+            "variables": "['F'=('1'),'A'=2]"
           }
         ]
       }
@@ -2705,7 +2705,7 @@
           },
           {
             "output": "",
-            "variables": "['F' = ('1'),'A' = 2]"
+            "variables": "['F'=('1'),'A'=2]"
           }
         ]
       }
@@ -2721,7 +2721,7 @@
         "stages": [
           {
             "output": "",
-            "variables": "['X' = 65]"
+            "variables": "['X'=65]"
           }
         ]
       }
@@ -2737,7 +2737,7 @@
         "stages": [
           {
             "output": "",
-            "variables": "['X' = 65]"
+            "variables": "['X'=65]"
           }
         ]
       }
@@ -2753,7 +2753,7 @@
         "stages": [
           {
             "output": "",
-            "variables": "['X' = 1]"
+            "variables": "['X'=1]"
           }
         ]
       }
@@ -2780,7 +2780,7 @@
         "stages": [
           {
             "output": "",
-            "variables": "['X' = 0]"
+            "variables": "['X'=0]"
           }
         ]
       }
@@ -2796,7 +2796,7 @@
         "stages": [
           {
             "output": "",
-            "variables": "['X' = 1]"
+            "variables": "['X'=1]"
           }
         ]
       }
@@ -2823,7 +2823,7 @@
         "stages": [
           {
             "output": "",
-            "variables": "['X' = 2]"
+            "variables": "['X'=2]"
           }
         ]
       }
@@ -2839,7 +2839,7 @@
         "stages": [
           {
             "output": "",
-            "variables": "['X' = 2]"
+            "variables": "['X'=2]"
           }
         ]
       }
@@ -2855,7 +2855,7 @@
         "stages": [
           {
             "output": "",
-            "variables": "['X' = 1]"
+            "variables": "['X'=1]"
           }
         ]
       }
@@ -2871,7 +2871,7 @@
         "stages": [
           {
             "output": "",
-            "variables": "['X' = 0 + 1]"
+            "variables": "['X'=0+1]"
           }
         ]
       }
@@ -2957,7 +2957,7 @@
             "variables": "[]"
           },
           {
-            "output": "' op' []",
+            "output": "' op'[]",
             "variables": "[]"
           }
         ]
@@ -2984,7 +2984,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "- (a * b)",
+            "output": "-(a*b)",
             "variables": "[]"
           }
         ]
@@ -3000,7 +3000,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "\\ (a * b)",
+            "output": "\\(a*b)",
             "variables": "[]"
           }
         ]
@@ -3086,7 +3086,7 @@
             "variables": "[]"
           },
           {
-            "output": "- [1]",
+            "output": "-[1]",
             "variables": "[]"
           }
         ]
@@ -3107,7 +3107,7 @@
           },
           {
             "output": "",
-            "variables": "['X' = [1|e]]"
+            "variables": "['X'=[1|e]]"
           }
         ]
       }
@@ -3131,7 +3131,7 @@
           },
           {
             "output": "",
-            "variables": "['X' = 1]"
+            "variables": "['X'=1]"
           }
         ]
       }
@@ -3711,7 +3711,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "'.' + '.'",
+            "output": "'.'+'.'",
             "variables": "[]"
           }
         ]
@@ -3795,7 +3795,7 @@
         "stages": [
           {
             "output": "9.8813129168249309e-324",
-            "variables": "['X' = 9.8813129168249309e-324]"
+            "variables": "['X'=9.8813129168249309e-324]"
           }
         ]
       }
@@ -3843,7 +3843,7 @@
         "stages": [
           {
             "output": "",
-            "variables": "['T' = t(1,1,1)]"
+            "variables": "['T'=t(1,1,1)]"
           }
         ]
       }
@@ -3859,7 +3859,7 @@
         "stages": [
           {
             "output": "",
-            "variables": "['X' = 1]"
+            "variables": "['X'=1]"
           }
         ]
       }
@@ -3894,7 +3894,7 @@
             "variables": "[]"
           },
           {
-            "output": "a --> b, c '|' d",
+            "output": "a-->b,c'|'d",
             "variables": "[]"
           }
         ]
@@ -3965,7 +3965,7 @@
             "variables": "[]"
           },
           {
-            "output": "[(a '|' b)]",
+            "output": "[(a'|'b)]",
             "variables": "[]"
           }
         ]
@@ -3985,7 +3985,7 @@
             "variables": "[]"
           },
           {
-            "output": "[a,(b, c)]",
+            "output": "[a,(b,c)]",
             "variables": "[]"
           }
         ]
@@ -4002,7 +4002,7 @@
         "stages": [
           {
             "output": "",
-            "variables": "['X' = 7]"
+            "variables": "['X'=7]"
           }
         ]
       }
@@ -4018,7 +4018,7 @@
         "stages": [
           {
             "output": "",
-            "variables": "['X' = 7]"
+            "variables": "['X'=7]"
           }
         ]
       }
@@ -4097,7 +4097,7 @@
         "stages": [
           {
             "output": "'\\0\\'",
-            "variables": "['C' = '\\0\\']"
+            "variables": "['C'='\\0\\']"
           }
         ]
       }
@@ -4145,7 +4145,7 @@
         "stages": [
           {
             "output": "+(_A,_A)",
-            "variables": "['B' = B]"
+            "variables": "['B'=B]"
           }
         ]
       }
@@ -4219,7 +4219,7 @@
             "variables": "[]"
           },
           {
-            "output": "f (1, 2)",
+            "output": "f (1,2)",
             "variables": "[]"
           }
         ]
@@ -4282,7 +4282,7 @@
             "variables": "[]"
           },
           {
-            "output": "a >. > b",
+            "output": "a>. >b",
             "variables": "[]"
           }
         ]
@@ -4393,7 +4393,7 @@
             "variables": "[]"
           },
           {
-            "output": ">(a) > b",
+            "output": ">(a)>b",
             "variables": "[]"
           }
         ]
@@ -4693,7 +4693,7 @@
         "stages": [
           {
             "output": "",
-            "variables": "['C' = ' ']"
+            "variables": "['C'=' ']"
           }
         ]
       }
@@ -4709,7 +4709,7 @@
         "stages": [
           {
             "output": "",
-            "variables": "['C' = '%']"
+            "variables": "['C'='%']"
           }
         ]
       }
@@ -4735,7 +4735,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "-- a",
+            "output": "--a",
             "variables": "[]"
           }
         ]
@@ -4751,7 +4751,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "-- a",
+            "output": "--a",
             "variables": "[]"
           },
           {
@@ -4803,7 +4803,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "0 + 1",
+            "output": "0+1",
             "variables": "[]"
           }
         ]
@@ -4841,7 +4841,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "[(a, b)]",
+            "output": "[(a,b)]",
             "variables": "[]"
           }
         ]
@@ -4857,7 +4857,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "1 = \\\\",
+            "output": "1= \\\\",
             "variables": "[]"
           }
         ]
@@ -4923,7 +4923,7 @@
         "stages": [
           {
             "output": "",
-            "variables": "['T' = (a, b)]"
+            "variables": "['T'=(a,b)]"
           }
         ]
       }
@@ -4958,7 +4958,7 @@
             "variables": "[]"
           },
           {
-            "output": "~ (a = b)",
+            "output": "~(a=b)",
             "variables": "[]"
           }
         ]
@@ -4974,7 +4974,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "\\ (a = b)",
+            "output": "\\(a=b)",
             "variables": "[]"
           }
         ]
@@ -4990,7 +4990,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "+ (a = b)",
+            "output": "+(a=b)",
             "variables": "[]"
           }
         ]
@@ -5038,7 +5038,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "{a, b}",
+            "output": "{a,b}",
             "variables": "[]"
           }
         ]
@@ -5076,7 +5076,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "+ (1 * 2) ^ 3",
+            "output": "+(1*2)^3",
             "variables": "[]"
           }
         ]
@@ -5092,7 +5092,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "- ((1 * 2) ^ 3)",
+            "output": "-((1*2)^3)",
             "variables": "[]"
           }
         ]
@@ -5108,7 +5108,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "[a|\\+ 2]",
+            "output": "[a|\\+2]",
             "variables": "[]"
           }
         ]
@@ -5293,7 +5293,7 @@
             "variables": "[]"
           },
           {
-            "output": "a .> .>",
+            "output": "a.> .>",
             "variables": "[]"
           }
         ]
@@ -5451,7 +5451,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "{a :- b}",
+            "output": "{a:-b}",
             "variables": "[]"
           }
         ]
@@ -5555,7 +5555,16 @@
       "input": "writeq(?).",
       "readCount": 1,
       "expected": "?",
-      "assertion": "upstream"
+      "assertion": "upstream",
+      "outcome": {
+        "type": "success",
+        "stages": [
+          {
+            "output": "?",
+            "variables": "[]"
+          }
+        ]
+      }
     }
   ],
   "sourceRevision": "1.300",

package/test/run-regression.mjs

@@ -1333,6 +1333,24 @@ c4 ?- call((!;1)).
         assertEqual(result.stdout, 'quads: 1 run, 1 passed, 0 failed.\n', 'quad report');
       },
     },
+    {
+      name: 'quad recursion-cycle evidence consistently refutes finite failure (issue #58 comment 5381101420)',
+      run: () => {
+        const result = publicApi.runQuads(`inf :- inf, inf.
+
+23
+?- inf.
+   loops.
+   false.
+`);
+        assertEqual(result.total, 2, 'quad total');
+        assertEqual(result.passed, 1, 'loops passed');
+        assertEqual(result.failed, 1, 'false failed');
+        assertEqual(result.undecided, 0, 'no undecided result');
+        assertIncludes(result.stdout, 'expected: false.', 'finite failure diagnostic');
+        assertNotIncludes(result.stdout, 'undecided: recursion cycle encountered.', 'cycle is decisive');
+      },
+    },
     {
       name: 'quad search-budget exhaustion is undecided rather than loops or failure (issue #58)',
       run: () => {
@@ -1383,6 +1401,21 @@ c4 ?- call((!;1)).
         assertIncludes(nsto.stdout, 'quads: FAILED 34, <input>:1', 'NSTO diagnostic');
       },
     },
+    {
+      name: 'quads peeks/1 supplies one unconsumed look-ahead character (issue #62)',
+      run: () => {
+        const result = publicApi.runQuads(`29
+?- read(X).
+   inputs("1."), X = 1, unexpected.
+   inputs("1."), peeks(" "), X = 1.
+   inputs("1. "), peeks(" "), X = 1, unexpected.
+`);
+        assertEqual(result.total, 3, 'quad total');
+        assertEqual(result.passed, 3, 'quad passed');
+        assertEqual(result.failed, 0, 'quad failed');
+        assertEqual(result.stdout, 'quads: 3 run, 3 passed, 0 failed.\n', 'quad report');
+      },
+    },
     {
       name: 'outputs/1 accepts DCG bodies over captured characters (issue #59)',
       run: () => {
@@ -3282,6 +3315,28 @@ child.stdin.write(\`consult(${consultedAtom}).\\n\`);
         }
       },
     },
+    {
+      name: 'read and read_term report invalid UTF-8 as representation_error(character) (issue #64)',
+      run: () => {
+        const invalidPath = path.join(tmp, `read-invalid-utf8-${++tmpCounter}.bin`);
+        fs.writeFileSync(invalidPath, Buffer.from([0xff]));
+        const quotedPath = sourceAtom(invalidPath);
+        for (const goal of [
+          `open(${quotedPath}, read, S, []), read(S, C)`,
+          `open(${quotedPath}, read, S, []), read_term(S, C, [])`,
+          `open(${quotedPath}, read, S, []), set_input(S), read(C)`,
+          `open(${quotedPath}, read, S, []), set_input(S), read_term(C, [])`,
+        ]) {
+          let caught = null;
+          try {
+            run('', { goal });
+          } catch (error) {
+            caught = error;
+          }
+          assertEqual(caught?.formal, 'representation_error(character)', `${goal} invalid UTF-8`);
+        }
+      },
+    },
     {
       name: 'writeq gives unnamed variables underscore-prefixed names (issue #53)',
       run: () => {
@@ -3310,6 +3365,13 @@ child.stdin.write(\`consult(${consultedAtom}).\\n\`);
         );
       },
     },
+    {
+      name: 'writeq separates operators only where lexical ambiguity requires it (issue #63)',
+      run: () => {
+        const source = "emit :- writeq(1+2), put_char('|'), writeq(a+ -b), put_char('|'), writeq(a+b*c), nl.\n";
+        assertEqual(run(source, { goal: 'emit' }).stdout, '1+2|a+ -b|a+b*c\nemit.\n', 'minimal operator spacing');
+      },
+    },
     {
       name: 'write predicates and write_term options select distinct formats',
       run: () => {
@@ -3332,7 +3394,7 @@ child.stdin.write(\`consult(${consultedAtom}).\\n\`);
         ].join('\n');
         assertEqual(
           run(source, { goal: 'emit' }).stdout,
-          "hello world|'hello world'|a + b * c|+(a,*(b,c))|hello world|'hello world'|+(a,b)|a + b|A|$VAR(0)|pair(Left,Right)|\"ab\"|[a,b]emit.\n",
+          "hello world|'hello world'|a+b*c|+(a,*(b,c))|hello world|'hello world'|+(a,b)|a+b|A|$VAR(0)|pair(Left,Right)|\"ab\"|[a,b]emit.\n",
           'stdout',
         );
       },

package/the-art-of-eyeprolog.md

@@ -5412,8 +5412,11 @@ 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]`.
+syntax, so functional arguments, list elements, and operator applications are
+emitted compactly when no lexical ambiguity would arise. For example,
+`writeq([a,b])` outputs `[a,b]` and `writeq(1+2)` outputs `1+2`; a separator is
+still retained where adjacent graphic tokens would otherwise merge, as in
+`a+ -b`.
 `write_term/2-3` supports `quoted/1`, `ignore_ops/1`, `numbervars/1`, and
 `variable_names/1`.
 
@@ -6891,13 +6894,26 @@ variable in the renamed exception term. `...` and `ad_infinitum` accept further
 indented descriptions after one query are independent checks: each re-runs the
 query, each is counted in the `quads:` summary, and a failing description does
 not suppress later descriptions for that query. `inputs/1` supplies and checks
-consumed characters. `outputs/1` checks characters emitted while reaching the
-described answer or error, including output produced before a later exception.
-Its argument may be an exact character list/string or a DCG body: terminal
-sequences, conjunction/disjunction, `...`/`ad_infinitum` sequence wildcards,
-and user-defined DCG nonterminals are matched against the captured characters.
-The advanced stream annotations `peeks/1` and `waits`, and the unordered
-`other_answer_sequence` annotation, are not executed by the current runner.
+exactly the characters consumed by the query. `peeks/1` may add one character
+that is available for look-ahead but must remain unconsumed. The runner puts an
+invalid-character sentinel immediately after the declared input boundary, so a
+reader cannot accidentally use an artificial end-of-file to decide that a full
+stop terminates the term. For example:
+
+```eyeprolog
+?- read(X).
+   inputs("1."), X = 1, unexpected.
+   inputs("1."), peeks(" "), X = 1.
+   inputs("1. "), peeks(" "), X = 1, unexpected.
+```
+
+`outputs/1` checks characters emitted while reaching the described answer or
+error, including output produced before a later exception. Its argument may be
+an exact character list/string or a DCG body: terminal sequences,
+conjunction/disjunction, `...`/`ad_infinitum` sequence wildcards, and
+user-defined DCG nonterminals are matched against the captured characters.
+The `waits` and unordered `other_answer_sequence` annotations are not executed
+by the current runner.
 
 #### STO, loops, and undecided quad results
 
@@ -6933,7 +6949,10 @@ does not guess.
 
 `loops` is kept distinct from merely exhausting the quad runner's resources.
 EyeProlog accepts structural nontermination evidence such as an active-variant
-recursion cycle, with the loop depth/inference bounds as a bounded fallback:
+recursion cycle, with the loop depth/inference bounds as a bounded fallback. A
+structural cycle is also strong enough to refute a finite `false` description;
+it is not reported as undecided merely because the same query was checked by a
+different answer description:
 
 ```eyeprolog
 inf :- inf, inf.