eyeprolog 1.3.70 → 1.3.72

package/README.md

@@ -151,7 +151,9 @@ top level includes pending `dif/2` goals in residual answers. See
 
 `library(atts)` exposes Scryer-style attributed-variable operations on the same
 persistent `Env` machinery used by `dif/2`: `put_atts/2`, `get_atts/2`,
-`put_attr/3`, `get_attr/3`, `del_attr/2`, and `term_attributed_variables/2`.
+`put_attr/3`, `get_attr/3`, `del_attr/2`, `term_attributed_variables/2`, and
+`call_residue_vars/2`. The latter reports variables whose residual attributes or
+constraints were created or modified by a goal, including native `dif/2` residues.
 `:- attribute ...` declarations are accepted, `verify_attributes/3` runs before
 an attributed binding is committed, and the hook's returned goals run after
 that binding. Attribute state follows variable representatives and ordinary
@@ -359,7 +361,8 @@ lambda syntax also changes the active operator table.
 Outside `--iso-strict`, an otherwise undefined unqualified call may autoload a
 predicate only when the interop profile has one canonical EyeProlog provider.
 For example, `member/2` autoloads from `library(lists)`, `call_nth/2` from
-`library(iso_ext)`, and `between/3` from EyeProlog's internal
+`library(iso_ext)`, `call_residue_vars/2` from `library(atts)`, and `between/3`
+from EyeProlog's internal
 `library(prologue)` implementation. Use `--no-autoload` to disable this
 convenience. Strict ISO mode never autoloads library predicates.
 

package/examples/dif-constraints.pl

@@ -11,8 +11,8 @@ allowed_pair(X, Y) :-
     X = left,
     Y = right.
 
-% The structural constraint remains pending after X=Y. Binding both to 1
-% then proves X-Y and 1-2 different, so the constraint is discharged.
+% X=Y already proves X-Y and 1-2 different: X-X cannot unify with 1-2,
+% so the dif/2 constraint is discharged before the final specialization Y=1.
 specialization(X, Y) :-
     dif(X-Y, 1-2),
     X = Y,

package/package.json

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

package/src/iso.js

@@ -165,6 +165,7 @@ export const isoBuiltins = {
 export const eyePrologLibraryBuiltins = {
   register(registry) {
     registry.add('eyeprolog__call_nth', 2, callNthBuiltin, { eyePrologLibrary: true });
+    registry.add('eyeprolog__call_residue_vars', 2, callResidueVarsBuiltin, { eyePrologLibrary: true });
     registry.add('eyeprolog__countall', 2, countAllBuiltin, { eyePrologLibrary: true });
     registry.add('eyeprolog__freeze', 2, freezeBuiltin, { eyePrologLibrary: true });
     registry.add('dif', 2, difBuiltin, { deterministic: true, eyePrologLibrary: true });
@@ -2497,6 +2498,79 @@ function* callNthBuiltin({ solver, goal, env }) {
   }
 }
 
+function residueSnapshot(env) {
+  const attributes = new Map();
+  for (const name of env.attributedVariableNames?.() ?? []) {
+    attributes.set(name, env.prologAttributes(name));
+  }
+  const delays = new Map();
+  for (const name of env.delayedVariableNames?.() ?? []) {
+    delays.set(name, env.delayedGoals(name));
+  }
+  const constraints = new Map();
+  for (const constraint of env.variableConstraints?.() ?? []) {
+    constraints.set(constraint, [...constraint.variables(env)]);
+  }
+  return { attributes, delays, constraints };
+}
+
+function sameAttributeEntries(before, after) {
+  if (before == null || before.length !== after.length) return false;
+  for (let i = 0; i < after.length; i++) {
+    if (before[i].module !== after[i].module || before[i].attribute !== after[i].attribute) return false;
+  }
+  return true;
+}
+
+function sameDelayEntries(before, after) {
+  if (before == null || before.length !== after.length) return false;
+  for (let i = 0; i < after.length; i++) if (before[i] !== after[i]) return false;
+  return true;
+}
+
+function residueVariablesSince(snapshot, env) {
+  const names = [];
+  const seen = new Set();
+  const add = (name) => {
+    const root = deref(variable(name), env);
+    if (root.type !== VAR || seen.has(root.name)) return;
+    seen.add(root.name);
+    names.push(root);
+  };
+
+  for (const name of env.attributedVariableNames?.() ?? []) {
+    const after = env.prologAttributes(name);
+    if (!sameAttributeEntries(snapshot.attributes.get(name), after)) add(name);
+  }
+  for (const name of env.delayedVariableNames?.() ?? []) {
+    const after = env.delayedGoals(name);
+    if (!sameDelayEntries(snapshot.delays.get(name), after)) add(name);
+  }
+  for (const constraint of env.variableConstraints?.() ?? []) {
+    const after = [...constraint.variables(env)];
+    const before = snapshot.constraints.get(constraint);
+    const unchanged = before != null && before.length === after.length && before.every((name, index) => name === after[index]);
+    if (unchanged) continue;
+    for (const name of after) add(name);
+  }
+  return names;
+}
+
+function* callResidueVarsBuiltin({ solver, goal, env }) {
+  const invoked = callable(goal.args[0], env);
+  if (invoked.module == null) invoked.module = goal.module ?? 'user';
+  const snapshot = residueSnapshot(env);
+  const child = solver.cloneForInnerGoal();
+  try {
+    for (const answerEnv of child.solve([invoked], env, 0)) {
+      const next = answerEnv.clone();
+      if (unify(goal.args[1], listFromItems(residueVariablesSince(snapshot, answerEnv)), next)) yield next;
+    }
+  } finally {
+    solver.absorbStatsFrom(child);
+  }
+}
+
 function* freezeBuiltin({ solver, goal, env }) {
   const watched = deref(goal.args[0], env);
   if (watched.type !== VAR) {

package/src/lib/atts.pl

@@ -12,9 +12,14 @@
     put_attr/3,
     get_attr/3,
     del_attr/2,
-    term_attributed_variables/2
+    term_attributed_variables/2,
+    call_residue_vars/2
 ]).
 :- op(1199, fx, attribute).
+:- meta_predicate(call_residue_vars(0, '?')).
 
 term_attributed_variables(Term, Variables) :-
     '$term_attributed_variables'(Term, Variables).
+
+call_residue_vars(Goal, Variables) :-
+    eyeprolog__call_residue_vars(Goal, Variables).

package/src/repl.js

@@ -672,18 +672,18 @@ async function solveQuery(engine, state, goal, reader, output) {
 }
 
 function pullSolution(solver, solutions, reader) {
-  const stream = solver.io.resolve('user_output');
-  const originalWrite = stream?.write;
-  let captured = '';
-  if (stream) stream.write = (text) => { captured += String(text); };
+  // Prolog output is an observable side effect of execution, so never hold it
+  // until the search reaches its next leaf. In particular an infinite search
+  // that periodically writes progress must remain observable at the terminal.
+  // Completed queries keep the same byte order because user_output writes are
+  // synchronous and occur before solutions.next() returns its answer.
   const suspended = reader.suspendForComputation();
   try {
-    return { result: solutions.next(), output: captured };
+    return { result: solutions.next(), output: '' };
   } catch (error) {
-    return { error, output: captured };
+    return { error, output: '' };
   } finally {
     reader.resumeAfterComputation(suspended);
-    if (stream) stream.write = originalWrite;
   }
 }
 

package/src/standard-library.js

@@ -63,7 +63,7 @@ function libraryUrl(filename) {
 
 export const eyePrologNativeLibraryIndicators = Object.freeze([
   'call_nth/2', 'freeze/2', 'dif/2', 'countall/2', 'time/1',
-  'put_atts/2', 'get_atts/2', 'put_attr/3', 'get_attr/3', 'del_attr/2', 'term_attributed_variables/2',
+  'put_atts/2', 'get_atts/2', 'put_attr/3', 'get_attr/3', 'del_attr/2', 'term_attributed_variables/2', 'call_residue_vars/2',
   '#>/2', '#</2', '#>=/2', '#=</2', '#=/2', '#\\=/2', '#\\/1',
   '#<==>/2', '#==>/2', '#<==/2', '#\\//2', '#\\/2', '#/\\/2',
   'in/2', 'ins/2', 'all_different/1', 'all_distinct/1', 'nvalue/2', 'sum/3',
@@ -133,6 +133,9 @@ export const eyePrologInteropAutoload = Object.freeze({
   // it from library(iso_ext), matching the explicit Scryer import while still
   // allowing Trealla-style unqualified source to use the same autoload entry.
   'call_nth/2': 'iso_ext',
+  // Scryer exposes call_residue_vars/2 from library(atts); autoload it for
+  // constraint-test source that uses the predicate without an explicit import.
+  'call_residue_vars/2': 'atts',
   // Trealla exposes time/1 as a meta timing predicate and library(iso_ext)
   // supplies ... //0. Autoload both so UWN's DCG hand-off benchmark runs
   // unchanged while their implementations remain outside the ISO core.

package/src/term.js

@@ -268,6 +268,28 @@ export class Env {
     delays.set(name, [...(delays.get(name) ?? []), { goal, module }]);
     this._delays = delays;
   }
+  delayedVariableNames() {
+    if (this._delays == null || this._delays.size === 0) return [];
+    const names = [];
+    const seen = new Set();
+    for (const name of this._delays.keys()) {
+      const root = deref(variable(name), this);
+      if (root.type !== VAR || seen.has(root.name)) continue;
+      seen.add(root.name);
+      names.push(root.name);
+    }
+    return names;
+  }
+  delayedGoals(name) {
+    const root = deref(variable(name), this);
+    if (root.type !== VAR || this._delays == null) return [];
+    const result = [];
+    for (const [source, goals] of this._delays) {
+      const current = deref(variable(source), this);
+      if (current.type === VAR && current.name === root.name) result.push(...goals);
+    }
+    return result;
+  }
   takeReadyDelays() {
     if (this._delays == null || this._delays.size === 0) return [];
     const ready = [];

package/src/write.js

@@ -86,7 +86,12 @@ function isWordOperatorToken(token) {
 
 function compactPrefixOperator(token, argument) {
   if (isWordOperatorToken(token)) return `${token} ${argument}`;
-  return `${token}${compactBoundaryNeedsSpace(token, argument) ? ' ' : ''}${argument}`;
+  // Without layout, `op(...)` is functional notation rather than prefix-operator
+  // notation. ISO 7.10.5 h requires operator-form output and layout whenever
+  // ambiguity could otherwise arise, so a parenthesized prefix argument must
+  // never be glued directly to the operator token.
+  const needsLayout = argument.startsWith('(') || compactBoundaryNeedsSpace(token, argument);
+  return `${token}${needsLayout ? ' ' : ''}${argument}`;
 }
 
 function compactPostfixOperator(argument, token) {
@@ -188,28 +193,6 @@ function chooseOperator(term, table) {
   return null;
 }
 
-function startsWithUnsignedNumber(term, env, table, options) {
-  const resolved = deref(term, env);
-  if (resolved.type === NUMBER) return !resolved.name.startsWith('-');
-  if (resolved.type !== COMPOUND || isCons(resolved)) return false;
-  if (options.numbervars && resolved.name === '$VAR' && resolved.arity === 1) {
-    const index = deref(resolved.args[0], env);
-    if (index.type === NUMBER && /^\d+$/.test(index.name) &&
-        writeNumberedVariable(Number(index.name)) != null) {
-      return false;
-    }
-  }
-  const definition = chooseOperator(resolved, table);
-  if (definition == null) return false;
-  if (definition.specifier === 'xf' || definition.specifier === 'yf') {
-    return startsWithUnsignedNumber(resolved.args[0], env, table, options);
-  }
-  if (definition.specifier === 'xfx' || definition.specifier === 'xfy' || definition.specifier === 'yfx') {
-    return startsWithUnsignedNumber(resolved.args[0], env, table, options);
-  }
-  return false;
-}
-
 function printableReadVariableNames(term, env, explicit) {
   const names = new Map(explicit);
   const used = new Set(names.values());
@@ -353,13 +336,30 @@ function format(term, env, options, table, maxPriority = 1200, context = 'term')
       let text;
       if (specifier === 'fx' || specifier === 'fy') {
         const argumentPriority = specifier === 'fx' ? priority - 1 : priority;
-        // A separated `- 1` is still read as the negative number -1.  When
-        // the source term is the unary -/1 compound, parenthesize a positive
-        // 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)) {
+        // Corrigendum 3 adds mandatory parentheses for prefix - when its
+        // argument is a non-negative number or is written in infix/postfix
+        // operator form (ISO 7.10.5 h 2(iii-iv)).
+        const child = deref(resolved.args[0], env);
+        const childNumbervar = options.numbervars && child.type === COMPOUND &&
+          child.name === '$VAR' && child.arity === 1 && (() => {
+            const index = deref(child.args[0], env);
+            return index.type === NUMBER && /^\d+$/.test(index.name) &&
+              writeNumberedVariable(Number(index.name)) != null;
+          })();
+        const childUsesSpecialNotation = isCons(child) ||
+          (child.type === COMPOUND && child.name === '{}' && child.arity === 1) || childNumbervar;
+        const childDefinition = childUsesSpecialNotation ? null : chooseOperator(child, table);
+        const negativeNeedsParentheses = resolved.name === '-' && (
+          (child.type === NUMBER && !child.name.startsWith('-')) ||
+          ['xf', 'yf', 'xfx', 'xfy', 'yfx'].includes(childDefinition?.specifier)
+        );
+        if (negativeNeedsParentheses) {
+          // ISO 7.10.5 h 2(iii-iv): prefix - requires parentheses around a
+          // non-negative number and around an argument written in infix or
+          // postfix operator form. Keep layout before `(` so the result is
+          // operator notation, not functional notation such as `-(...)`.
           const argument = format(resolved.args[0], env, options, table, 1200);
-          text = options.minimalOperatorSpacing ? `${token}(${argument})` : `${token} (${argument})`;
+          text = `${token} (${argument})`;
         } else {
           const argument = format(resolved.args[0], env, options, table, argumentPriority);
           text = options.minimalOperatorSpacing ? compactPrefixOperator(token, argument) : `${token} ${argument}`;

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

@@ -11,10 +11,14 @@ upstream assertion.
 
 ## Current standing
 
+The percentage below is **traceability coverage**, not a conformance pass rate.
+A represented case still has to pass the executable upstream assertion in
+`test/run-wg17.mjs`.
+
 | Measure | Count |
 | --- | ---: |
 | Active upstream cases | 366 |
-| Executable EyeProlog dispositions | 366 (100.0%) |
+| Upstream cases represented in the executable matrix | 366 (100.0%) |
 | Not yet traced one-by-one | 0 |
 | Deleted upstream identifiers | #20, #273 |
 

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

@@ -522,7 +522,7 @@
       "query": "writeq([:-,-]).",
       "input": "writeq([:-,-]).",
       "readCount": 1,
-      "expected": "[:-,-] ³",
+      "expected": "[:-,-]",
       "outcome": {
         "type": "success",
         "stages": [
@@ -586,7 +586,7 @@
       "query": "writeq([.,.(.,.,.)]).",
       "input": "writeq([.,.(.,.,.)]).",
       "readCount": 1,
-      "expected": "['.','.'('.','.','.')] ³",
+      "expected": "['.','.'('.','.','.')]",
       "outcome": {
         "type": "success",
         "stages": [
@@ -602,7 +602,7 @@
       "query": "writeq((a :- b,c)).",
       "input": "writeq((a :- b,c)).",
       "readCount": 1,
-      "expected": "a:-b,c³",
+      "expected": "a:-b,c",
       "outcome": {
         "type": "success",
         "stages": [
@@ -618,7 +618,7 @@
       "query": "write_canonical([a]).",
       "input": "write_canonical([a]).",
       "readCount": 1,
-      "expected": "'.'(a,[])³",
+      "expected": "'.'(a,[])",
       "outcome": {
         "type": "success",
         "stages": [
@@ -1052,7 +1052,7 @@
       "query": "(- (1)) = -(1).",
       "input": "(- (1)) = -(1).",
       "readCount": 1,
-      "expected": "succeeds°",
+      "expected": "succeeds",
       "outcome": {
         "type": "success",
         "stages": [
@@ -1068,7 +1068,7 @@
       "query": "(- -1) = -(-1).",
       "input": "(- -1) = -(-1).",
       "readCount": 1,
-      "expected": "succeeds°",
+      "expected": "succeeds",
       "outcome": {
         "type": "success",
         "stages": [
@@ -1084,7 +1084,7 @@
       "query": "(- 1^2) = ^(-1,2).",
       "input": "(- 1^2) = ^(-1,2).",
       "readCount": 1,
-      "expected": "succeeds°",
+      "expected": "succeeds",
       "outcome": {
         "type": "success",
         "stages": [
@@ -1303,12 +1303,12 @@
       "query": "writeq(-(1)).",
       "input": "writeq(-(1)).",
       "readCount": 1,
-      "expected": "- (1)³",
+      "expected": "- (1)",
       "outcome": {
         "type": "success",
         "stages": [
           {
-            "output": "-(1)",
+            "output": "- (1)",
             "variables": "[]"
           }
         ]
@@ -1335,12 +1335,12 @@
       "query": "writeq(-(1^2)).",
       "input": "writeq(-(1^2)).",
       "readCount": 1,
-      "expected": "- (1^2)³",
+      "expected": "- (1^2)",
       "outcome": {
         "type": "success",
         "stages": [
           {
-            "output": "-(1^2)",
+            "output": "- (1^2)",
             "variables": "[]"
           }
         ]
@@ -1351,12 +1351,12 @@
       "query": "writeq(-(a^2)).",
       "input": "writeq(-(a^2)).",
       "readCount": 1,
-      "expected": "- (a^2)³",
+      "expected": "- (a^2)",
       "outcome": {
         "type": "success",
         "stages": [
           {
-            "output": "-a^2",
+            "output": "- (a^2)",
             "variables": "[]"
           }
         ]
@@ -1367,12 +1367,12 @@
       "query": "writeq(-((a,b))).",
       "input": "writeq(-((a,b))).",
       "readCount": 1,
-      "expected": "- (a,b)³",
+      "expected": "- (a,b)",
       "outcome": {
         "type": "success",
         "stages": [
           {
-            "output": "-(a,b)",
+            "output": "- (a,b)",
             "variables": "[]"
           }
         ]
@@ -1388,7 +1388,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "-(1*2)",
+            "output": "- (1*2)",
             "variables": "[]"
           }
         ]
@@ -1420,7 +1420,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "-(-)",
+            "output": "- (-)",
             "variables": "[]"
           }
         ]
@@ -1431,7 +1431,7 @@
       "query": "writeq(-[-]).",
       "input": "writeq(-[-]).",
       "readCount": 1,
-      "expected": "-[-] ³",
+      "expected": "-[-]",
       "outcome": {
         "type": "success",
         "stages": [
@@ -1479,7 +1479,7 @@
       "query": "writeq(-{a}).",
       "input": "writeq(-{a}).",
       "readCount": 1,
-      "expected": "-{a}³",
+      "expected": "-{a}",
       "outcome": {
         "type": "success",
         "stages": [
@@ -1532,7 +1532,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "- -(1)",
+            "output": "- - (1)",
             "variables": "[]"
           }
         ]
@@ -1543,7 +1543,7 @@
       "query": "op(100,yfx,~).\nwriteq(-(1~2~3)).",
       "input": "op(100,yfx,~).\nwriteq(-(1~2~3)).",
       "readCount": 2,
-      "expected": "- (1~2~3)³",
+      "expected": "- (1~2~3)",
       "outcome": {
         "type": "success",
         "stages": [
@@ -1552,7 +1552,7 @@
             "variables": "[]"
           },
           {
-            "output": "-(1~2~3)",
+            "output": "- (1~2~3)",
             "variables": "[]"
           }
         ]
@@ -1563,7 +1563,7 @@
       "query": " /**/ writeq(- (1~2)).",
       "input": "(catch((op(100,yfx,~)), _, true) -> true ; true).\n  writeq(- (1~2)).",
       "readCount": 2,
-      "expected": "- (1~2)³",
+      "expected": "- (1~2)",
       "outcome": {
         "type": "success",
         "stages": [
@@ -1572,7 +1572,7 @@
             "variables": "[]"
           },
           {
-            "output": "-(1~2)",
+            "output": "- (1~2)",
             "variables": "[]"
           }
         ]
@@ -1619,7 +1619,7 @@
       "query": "op(9,xf,'$VAR'), writeq(- '$VAR'(0)).",
       "input": "op(9,xf,'$VAR'), writeq(- '$VAR'(0)).",
       "readCount": 1,
-      "expected": "-A ³",
+      "expected": "-A",
       "outcome": {
         "type": "success",
         "stages": [
@@ -1695,7 +1695,7 @@
       "query": "compound(+1).",
       "input": "compound(+1).",
       "readCount": 1,
-      "expected": "succeeds ²",
+      "expected": "succeeds",
       "outcome": {
         "type": "success",
         "stages": [
@@ -1711,7 +1711,7 @@
       "query": "compound(+ 1).",
       "input": "compound(+ 1).",
       "readCount": 1,
-      "expected": "succeeds ²",
+      "expected": "succeeds",
       "outcome": {
         "type": "success",
         "stages": [
@@ -1727,7 +1727,7 @@
       "query": "writeq(+1^2).",
       "input": "writeq(+1^2).",
       "readCount": 1,
-      "expected": "+1^2 ²",
+      "expected": "+1^2",
       "outcome": {
         "type": "success",
         "stages": [
@@ -1754,7 +1754,7 @@
       "query": "writeq([+{a},+[]]).",
       "input": "writeq([+{a},+[]]).",
       "readCount": 1,
-      "expected": "[+{a},+[]] ² ³",
+      "expected": "[+{a},+[]]",
       "outcome": {
         "type": "success",
         "stages": [
@@ -1819,7 +1819,7 @@
       "query": "op(999,xfy,'|').",
       "input": "op(999,xfy,'|').",
       "readCount": 1,
-      "expected": "p._e.(c., o.,'|') ²",
+      "expected": "p._e.(c., o.,'|')",
       "outcome": {
         "type": "error",
         "formal": "permission_error(create, operator)"
@@ -1952,7 +1952,7 @@
       "query": "current_op(200,fy,+).",
       "input": "current_op(200,fy,+).",
       "readCount": 1,
-      "expected": "succeeds ²",
+      "expected": "succeeds",
       "outcome": {
         "type": "success",
         "stages": [
@@ -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": "[]"
           }
         ]
@@ -3173,7 +3173,7 @@
       "query": "writeq('$VAR'(0)).",
       "input": "writeq('$VAR'(0)).",
       "readCount": 1,
-      "expected": "A ³",
+      "expected": "A",
       "outcome": {
         "type": "success",
         "stages": [
@@ -3738,7 +3738,7 @@
       "query": " /**/ writeq(\"a\").",
       "input": "(catch((set_prolog_flag(\n double_quotes,chars)), _, true) -> true ; true).\n  writeq(\"a\").",
       "readCount": 2,
-      "expected": "[a] ³",
+      "expected": "[a]",
       "outcome": {
         "type": "success",
         "stages": [
@@ -3885,7 +3885,7 @@
       "query": " /**/ writeq((a-->b,c|d)).",
       "input": "(catch((op(1105,xfy,'|')), _, true) -> true ; true).\n  writeq((a-->b,c|d)).",
       "readCount": 2,
-      "expected": "a-->b,c|d² ³",
+      "expected": "a-->b,c|d",
       "outcome": {
         "type": "success",
         "stages": [
@@ -3956,7 +3956,7 @@
       "query": " /**/ writeq([(a|b)]).",
       "input": "(catch((op(1105,xfy,'|')), _, true) -> true ; true).\n  writeq([(a|b)]).",
       "readCount": 2,
-      "expected": "[(a|b)] ³",
+      "expected": "[(a|b)]",
       "outcome": {
         "type": "success",
         "stages": [
@@ -4210,7 +4210,7 @@
       "query": "op(400,fx,f).\nwriteq(f/*.*/(1,2)).",
       "input": "op(400,fx,f).\nwriteq(f/*.*/(1,2)).",
       "readCount": 2,
-      "expected": "f (1,2)³",
+      "expected": "f (1,2)",
       "outcome": {
         "type": "success",
         "stages": [
@@ -4660,7 +4660,7 @@
       "query": "op(500, xfy, {}).",
       "input": "op(500, xfy, {}).",
       "readCount": 1,
-      "expected": "p._e.(c.,o.,{}) ²",
+      "expected": "p._e.(c.,o.,{})",
       "outcome": {
         "type": "error",
         "formal": "permission_error(create, operator)"
@@ -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": "[]"
           }
         ]
@@ -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": "[]"
           }
         ]

package/test/run-regression.mjs

@@ -132,7 +132,7 @@ function regressionCases() {
     {
       name: 'library(atts) provides Scryer-style attributed-variable hooks',
       run: () => {
-        const source = `:- module(attr_probe, [check_get/0, check_alias/0, check_ok/0, check_bad/0, check_conflict/0, check_backtrack/0, check_term_vars/0]).
+        const source = `:- module(attr_probe, [check_get/0, check_alias/0, check_ok/0, check_bad/0, check_conflict/0, check_backtrack/0, check_term_vars/0, check_residue_new/0, check_residue_unchanged/0, check_residue_modified/0, check_residue_dif/0]).
 :- use_module(library(atts)).
 :- attribute mark/1.
 attach(X, V) :- put_atts(X, mark(V)).
@@ -151,6 +151,10 @@ check_bad :- attach(X, 3), X = 4.
 check_conflict :- attach(X, a), attach(Y, b), X = Y.
 check_backtrack :- (attach(X, a), fail ; true), \\+ get_atts(X, mark(_)).
 check_term_vars :- attach(X, a), term_attributed_variables(pair(X,Y), [X]), var(Y), X = a.
+check_residue_new :- call_residue_vars(attach(X, a), Vs), Vs = [X].
+check_residue_unchanged :- attach(X, a), call_residue_vars(true, Vs), Vs = [], X = a.
+check_residue_modified :- attach(X, a), call_residue_vars(put_atts(X, mark(b)), Vs), Vs = [X], X = b.
+check_residue_dif :- call_residue_vars(dif(X,Y), Vs), Vs = [X,Y].
 `;
         assertIncludes(run(source, { goal: 'attr_probe:check_get' }).stdout, 'attr_probe:check_get.', 'get_atts/2');
         assertIncludes(run(source, { goal: 'attr_probe:check_alias' }).stdout, 'attr_probe:check_alias.', 'attribute transfer on aliasing');
@@ -159,6 +163,20 @@ check_term_vars :- attach(X, a), term_attributed_variables(pair(X,Y), [X]), var(
         assertEqual(run(source, { goal: 'attr_probe:check_conflict' }).stdout, '', 'same-module attributes are verified before aliasing');
         assertIncludes(run(source, { goal: 'attr_probe:check_backtrack' }).stdout, 'attr_probe:check_backtrack.', 'attributes backtrack with Env branches');
         assertIncludes(run(source, { goal: 'attr_probe:check_term_vars' }).stdout, 'attr_probe:check_term_vars.', 'term_attributed_variables/2');
+        assertIncludes(run(source, { goal: 'attr_probe:check_residue_new' }).stdout, 'attr_probe:check_residue_new.', 'call_residue_vars/2 reports newly attributed variables');
+        assertIncludes(run(source, { goal: 'attr_probe:check_residue_unchanged' }).stdout, 'attr_probe:check_residue_unchanged.', 'call_residue_vars/2 ignores unchanged pre-existing attributes');
+        assertIncludes(run(source, { goal: 'attr_probe:check_residue_modified' }).stdout, 'attr_probe:check_residue_modified.', 'call_residue_vars/2 reports modified attributes');
+        assertIncludes(run(source, { goal: 'attr_probe:check_residue_dif' }).stdout, 'attr_probe:check_residue_dif.', 'call_residue_vars/2 includes native dif/2 residual variables');
+        const freezeResidue = `:- use_module(library(atts)).
+:- use_module(library(prologue), [freeze/2]).
+check :- call_residue_vars(freeze(X,true), Vs), Vs = [X].
+`;
+        assertIncludes(run(freezeResidue, { goal: 'check' }).stdout, 'check.', 'call_residue_vars/2 includes delayed freeze/2 variables');
+        const clpzResidue = `:- use_module(library(atts)).
+:- use_module(library(clpz)).
+check :- call_residue_vars(X in 1..3, Vs), Vs = [X].
+`;
+        assertIncludes(run(clpzResidue, { goal: 'check' }).stdout, 'check.', 'call_residue_vars/2 includes CLP(Z) attributed variables');
 
         const residualFile = path.join(tmp, `atts-residual-${++tmpCounter}.pl`);
         fs.writeFileSync(residualFile, `:- use_module(library(atts)).
@@ -314,6 +332,19 @@ probe :- empty_assoc(A), copy_term_nat(A, _), bb_b_put(current, ok), bb_get(curr
           goal: "catch((VN=[[]],write_term(T,[variable_names(VN)])),error(E,_),writeq(E))",
         });
         assertEqual(list.stdout, 'domain_error(write_option,variable_names([[]]))', 'list culprit');
+
+        assertEqual(run('', { isoStrict: true, goal: 'writeq(-(1^2))' }).stdout.split('writeq(')[0],
+          '- (1^2)', 'writeq negative power layout');
+        assertEqual(run('', { isoStrict: true, goal: 'writeq(-(a^2))' }).stdout.split('writeq(')[0],
+          '- (a^2)', 'writeq symbolic negative power layout');
+        assertEqual(run('', {
+          isoStrict: true,
+          goal: "write_term(-X^2,[variable_names(['X'=X])])",
+        }).stdout, '- (X^2)', 'write_term variable_names negative power layout');
+        assertEqual(run('', {
+          isoStrict: true,
+          goal: "X=1,write_term(-X^2,[variable_names(['X'=X])])",
+        }).stdout.split('1 = 1')[0], '- (1^2)', 'write_term bound variable negative power layout');
       },
     },
     {
@@ -2077,6 +2108,53 @@ c4 ?- call((!;1)).
         assertEqual(advanced.stderr, '', 'advanced stderr');
       },
     },
+    {
+      name: 'REPL exposes output side effects while search is still running (issue #72)',
+      run: () => {
+        const helper = `
+          import { spawn } from 'node:child_process';
+
+          const child = spawn(${JSON.stringify(process.execPath)}, [${JSON.stringify(bin)}], {
+            cwd: ${JSON.stringify(packageRoot)},
+            stdio: ['pipe', 'pipe', 'pipe'],
+          });
+          child.stdout.setEncoding('utf8');
+          child.stderr.setEncoding('utf8');
+          let stdout = '';
+          let stderr = '';
+          child.stdout.on('data', (text) => { stdout += text; });
+          child.stderr.on('data', (text) => { stderr += text; });
+
+          async function waitFor(predicate, label) {
+            const deadline = Date.now() + 5000;
+            while (!predicate()) {
+              if (Date.now() >= deadline) {
+                child.kill('SIGKILL');
+                throw new Error(label + ' timeout; stdout=' + JSON.stringify(stdout) + '; stderr=' + JSON.stringify(stderr));
+              }
+              await new Promise((resolve) => setTimeout(resolve, 10));
+            }
+          }
+
+          child.stdin.write('use_module(library(iso_ext)).\\n');
+          await waitFor(() => stdout.includes('   true.\\n?- '), 'module import');
+          child.stdin.write('call_nth(repeat,Nth), (Nth mod 2=:=0->writeq(r(Nth)),nl;true),Nth<0.\\n');
+          await waitFor(() => stdout.includes('r(2)\\nr(4)\\n'), 'progress output');
+          if (stdout.includes('false.')) throw new Error('infinite search unexpectedly reached a leaf');
+          child.kill('SIGKILL');
+          await new Promise((resolve) => child.once('exit', resolve));
+          process.stdout.write('progress-visible');
+        `;
+        const result = spawnSync(process.execPath, [
+          '--input-type=module',
+          '--eval',
+          helper,
+        ], { cwd: packageRoot, encoding: 'utf8', timeout: 10000 });
+        if (result.error) throw result.error;
+        assertEqual(result.status, 0, `progress helper status; stderr=${result.stderr}`);
+        assertEqual(result.stdout, 'progress-visible', 'newline-terminated progress is visible before a leaf answer');
+      },
+    },
     {
       name: 'REPL bindings use argument syntax for operator atoms',
       run: () => {
@@ -3703,6 +3781,16 @@ function documentationSyncCases() {
         assertEqual(parsed[0].query, 'set_prolog_flag( double_quotes,chars).', 'normalized query');
       },
     },
+    {
+      name: 'WG17 upgrader removes presentation footnote markers from Codex text',
+      run: () => {
+        const rows = Array.from({ length: 120 }, (_, index) =>
+          `<tr><td>${index + 1}<td>writeq(-(1^2)).<td>- (1^2)&sup3;`).join('\n');
+        const html = `<table><tr><th>#<th>Query<th>Codex${rows}</table>`;
+        const parsed = parseWg17SyntaxTable(html);
+        assertEqual(parsed[0].expected, '- (1^2)', 'normalized Codex expectation');
+      },
+    },
     {
       name: 'WG17 upstream expectations independently validate reviewed outcomes',
       run: () => {
@@ -3719,6 +3807,22 @@ function documentationSyncCases() {
           true,
           'observable output',
         );
+        const negativePower = { id: 183, input: 'writeq(-(1^2)).' };
+        assertEqual(
+          matchesUpstreamExpectation('- (1^2)', { type: 'success', stages: [{ output: '-(1^2)', variables: '[]' }] }, negativePower),
+          false,
+          'mandatory operator/parenthesis layout is not erased',
+        );
+        assertEqual(
+          matchesUpstreamExpectation('- (a^2)', { type: 'success', stages: [{ output: '-a^2', variables: '[]' }] }, negativePower),
+          false,
+          'mandatory negative-power parentheses are not erased',
+        );
+        assertEqual(
+          matchesUpstreamExpectation('- (1^2)', { type: 'success', stages: [{ output: '- (1 ^ 2)', variables: '[]' }] }, negativePower),
+          true,
+          'non-semantic internal operator spacing remains flexible',
+        );
         const repeated = {
           id: 227, input: 'write_canonical(B+B).',
           outcome: { type: 'success', stages: [{ output: '+(_A,_A)', variables: "['B' = B]" }] },
@@ -4900,7 +5004,7 @@ answer(ok) :-
         assertEqual(Boolean(registry.get('is', 2)), true, 'ISO is/2 exists');
         assertEqual(Boolean(registry.get('append', 3)), false, 'append/3 is not ISO core');
         assertEqual(library.eyePrologLibrary, true, 'complete registry marker');
-        assertEqual(library.defs.size, 154, 'EyeProlog registry contains ISO definitions, cleanup controls, observability extensions, WFS tnot/1, and generic library adapters');
+        assertEqual(library.defs.size, 155, 'EyeProlog registry contains ISO definitions, cleanup controls, observability extensions, WFS tnot/1, and generic library adapters');
         assertEqual(Boolean(registry.get('phrase', 2)), true, 'Part 3 phrase/2 exists');
         assertEqual(Boolean(registry.get('phrase', 3)), true, 'Part 3 phrase/3 exists');
         assertEqual(registry.get('statistics', 0), null, 'statistics/0 is absent from the ISO registry');
@@ -4917,21 +5021,23 @@ answer(ok) :-
         assertEqual(Boolean(library.get('call_cleanup', 2)), true, 'call_cleanup/2 is an EyeProlog cleanup control');
         assertEqual(registry.get('setup_call_cleanup', 3), null, 'setup_call_cleanup/3 is absent from the ISO registry');
         assertEqual(Boolean(library.get('setup_call_cleanup', 3)), true, 'setup_call_cleanup/3 is an EyeProlog cleanup control');
-        assertEqual(registeredNativeEyePrologLibraryNames().length, 48, 'public native EyeProlog builtin count');
+        assertEqual(registeredNativeEyePrologLibraryNames().length, 49, 'public native EyeProlog builtin count');
         assertEqual(eyePrologPortableLibraryIndicators.length, 87, 'portable Prolog library count');
-        assertEqual(eyePrologInteropLibraryIndicators.length, 29, 'cross-implementation interop profile count');
+        assertEqual(eyePrologInteropLibraryIndicators.length, 30, 'cross-implementation interop profile count');
         assertEqual(eyePrologInteropLibraryModules.join(','), 'lists,iso_ext,lambda,atts', 'common explicit library module profile');
         assertEqual(eyePrologInteropAutoload['member/2'], 'lists', 'member/2 canonical autoload');
         assertEqual(eyePrologInteropAutoload['between/3'], 'prologue', 'between/3 canonical internal autoload');
         assertEqual(eyePrologInteropAutoload['call_nth/2'], 'iso_ext', 'call_nth/2 canonical interop autoload');
+        assertEqual(eyePrologInteropAutoload['call_residue_vars/2'], 'atts', 'call_residue_vars/2 canonical interop autoload');
         assertEqual(eyePrologInteropAutoload['time/1'], 'iso_ext', 'time/1 canonical interop autoload');
         assertEqual(eyePrologInteropAutoload['.../2'], 'iso_ext', '.../2 canonical interop autoload');
         assertEqual(eyePrologInteropAutoload['set_nth0/4'] ?? null, null, 'EyeProlog-only set_nth0/4 is not autoloadable');
-        assertEqual(eyePrologNativeLibraryIndicators.length, 48, 'native host library count');
+        assertEqual(eyePrologNativeLibraryIndicators.length, 49, 'native host library count');
         assertEqual(eyePrologNativeLibraryIndicators.slice(0, 3).join(','), 'call_nth/2,freeze/2,dif/2', 'control and constraint predicates requiring host support');
-        assertEqual(eyePrologLibraryIndicators.length, 135, 'complete EyeProlog library surface');
+        assertEqual(eyePrologLibraryIndicators.length, 136, 'complete EyeProlog library surface');
         assertEqual(registry.get('eyeprolog__call_nth', 2), null, 'private call_nth adapter is absent from ISO registry');
         assertEqual(Boolean(library.get('eyeprolog__call_nth', 2)), true, 'private call_nth adapter is registered for EyeProlog');
+        assertEqual(Boolean(library.get('eyeprolog__call_residue_vars', 2)), true, 'private call_residue_vars adapter is registered for EyeProlog');
         assertEqual(library.get('eyeprolog__call_nth', 2)?.eyePrologLibrary, true, 'private adapter is marked as library support');
         assertEqual(registry.get('eyeprolog__freeze', 2), null, 'private freeze adapter is absent from ISO registry');
         assertEqual(Boolean(library.get('eyeprolog__freeze', 2)), true, 'private freeze adapter is registered for EyeProlog');

package/test/run-wg17.mjs

@@ -140,6 +140,38 @@ function stripLayoutOutsideQuotes(text) {
   return output.replace(/\.$/, '').replace(/([eE])\+(?=\d)/g, '$1');
 }
 
+function leadingGraphicOperatorParenSignature(text) {
+  const source = presentationText(text);
+  let index = 0;
+  const operators = [];
+  while (index < source.length) {
+    const match = source.slice(index).match(/^[!#$&*+\-./<=>?@^~\\]+/);
+    if (match == null) return null;
+    operators.push(match[0]);
+    index += match[0].length;
+    const layoutStart = index;
+    while (/\s/.test(source[index] ?? '')) index++;
+    if (index === layoutStart) return null;
+    if (source[index] === '(') return operators;
+  }
+  return null;
+}
+
+function preservesLeadingOperatorParenLayout(expected, actual) {
+  const signature = leadingGraphicOperatorParenSignature(expected);
+  if (signature == null) return true;
+  const source = presentationText(actual);
+  let index = 0;
+  for (const operator of signature) {
+    if (!source.startsWith(operator, index)) return false;
+    index += operator.length;
+    const layoutStart = index;
+    while (/\s/.test(source[index] ?? '')) index++;
+    if (index === layoutStart) return false;
+  }
+  return source[index] === '(';
+}
+
 function normalizeExampleVariables(text) {
   const names = new Map();
   let next = 0;
@@ -248,6 +280,10 @@ function textExpectationMatches(expectedText, actual, item, example = false) {
       left = normalizeExampleVariables(left);
       right = normalizeExampleVariables(right);
     }
+    // Some Codex expectations intentionally carry a mandatory lexical
+    // boundary, notably Cor.3 prefix-operator cases such as `- (1^2)`. Do not
+    // erase that boundary before the semantic/layout-tolerant fallbacks below.
+    if (!preservesLeadingOperatorParenLayout(left, right)) continue;
     if (stripLayoutOutsideQuotes(left) === stripLayoutOutsideQuotes(right)) return true;
     if (termEquivalent(left, right, item)) return true;
     if (example) {

package/the-art-of-eyeprolog.md

@@ -6253,7 +6253,7 @@ between solution branches.
 | Module | Exported predicate indicators |
 | --- | --- |
 | `library(aggregate)` | `sumall/3`, `aggregate_min/5`, `aggregate_max/5` |
-| `library(atts)` | `put_atts/2`, `get_atts/2`, `put_attr/3`, `get_attr/3`, `del_attr/2`, `term_attributed_variables/2` |
+| `library(atts)` | `put_atts/2`, `get_atts/2`, `put_attr/3`, `get_attr/3`, `del_attr/2`, `term_attributed_variables/2`, `call_residue_vars/2` |
 | `library(clpz)` | `#>/2`, `#</2`, `#>=/2`, `#=</2`, `#=/2`, `#\=/2`, `#\/1`, `#<==>/2`, `#==>/2`, `#<==/2`, `#\//2`, `#\/2`, `#/\/2`, `in/2`, `ins/2`, `all_different/1`, `all_distinct/1`, `nvalue/2`, `sum/3`, `scalar_product/4`, `tuples_in/2`, `labeling/2`, `label/1`, `indomain/1`, `lex_chain/1`, `serialized/2`, `global_cardinality/2`, `global_cardinality/3`, `circuit/1`, `chain/2`, `element/3`, `zcompare/3`, `fd_var/1`, `fd_inf/2`, `fd_sup/2`, `fd_size/2`, `fd_dom/2` |
 | `library(comparison)` | `lt/2`, `gt/2`, `le/2`, `ge/2` |
 | `library(dates)` | `difference/3` |

package/tools/report-wg17-syntax-coverage.mjs

@@ -99,10 +99,14 @@ upstream assertion.
 
 ## Current standing
 
+The percentage below is **traceability coverage**, not a conformance pass rate.
+A represented case still has to pass the executable upstream assertion in
+\`test/run-wg17.mjs\`.
+
 | Measure | Count |
 | --- | ---: |
 | Active upstream cases | ${activeIds.length} |
-| Executable EyeProlog dispositions | ${coveredIds.length} (${percentage}%) |
+| Upstream cases represented in the executable matrix | ${coveredIds.length} (${percentage}%) |
 | Not yet traced one-by-one | ${untracedIds.length} |
 | Deleted upstream identifiers | ${formatRanges(manifest.upstream.deletedIds)} |
 

package/tools/upgrade-wg17.mjs

@@ -16,6 +16,7 @@ const namedEntities = new Map([
   ['amp', '&'], ['lt', '<'], ['gt', '>'], ['quot', '"'], ['apos', "'"],
   ['nbsp', '\u00a0'], ['ndash', '–'], ['mdash', '—'], ['minus', '−'],
   ['hellip', '…'], ['middot', '·'], ['times', '×'], ['laquo', '«'], ['raquo', '»'],
+  ['sup2', '²'], ['sup3', '³'], ['deg', '°'],
 ]);
 
 export function decodeHtmlEntities(text) {
@@ -96,7 +97,7 @@ export function parseWg17SyntaxTable(html) {
     // They are not part of the Prolog source being specified, so normalize
     // them to ordinary spaces before snapshotting/comparing rows.
     const query = htmlCellText(cells[1]).replace(/\u00a0/g, ' ');
-    const expected = htmlCellText(cells[2]).replace(/\u00a0/g, ' ').replace(/[ \t\n]+/g, ' ').trim();
+    const expected = htmlCellText(cells[2]).replace(/\u00a0/g, ' ').replace(/[²³°]/g, '').replace(/[ \t\n]+/g, ' ').trim();
     if (query.length === 0 || expected.length === 0) continue;
     cases.push({ id, query, expected });
     seen.add(id);