eyeprolog 1.3.26 → 1.3.28

package/conformance-report.md

@@ -18,9 +18,10 @@ This report summarizes the file-based conformance corpus under `test/conformance
 | proofs | 0 | 0 | 0 | 21 | 21 |
 | query | 8 | 2 | 0 | 0 | 10 |
 | rules | 13 | 3 | 0 | 0 | 16 |
+| stc | 5 | 4 | 0 | 0 | 9 |
 | strings | 40 | 0 | 0 | 0 | 40 |
 | syntax | 12 | 23 | 0 | 0 | 35 |
 | terms | 26 | 3 | 0 | 0 | 29 |
 | unification | 18 | 0 | 0 | 0 | 18 |
 | variables | 16 | 7 | 0 | 0 | 23 |
-| **Total** | **484** | **267** | **19** | **21** | **791** |
+| **Total** | **489** | **271** | **19** | **21** | **800** |

package/package.json

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

package/src/iso.js

@@ -1322,6 +1322,7 @@ function* readTermBuiltin({ solver, goal, env }) {
 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 };
 }
 
@@ -1361,7 +1362,7 @@ function writeVariableNames(value, env, option) {
   return names;
 }
 
-function termWriteOptions(term, env, mode = 'write') {
+function termWriteOptions(term, env, mode = 'write_term') {
   const result = defaultTermWriteOptions(mode);
   for (const option of optionList(term, env)) {
     if (option.type === VAR) throw new PrologError('instantiation_error');
@@ -2403,7 +2404,8 @@ function evaluateOperation(term, args) {
   if (name === '/' && y === 0) throw new PrologError('evaluation_error(zero_divisor)');
   let value;
   if (name === 'max' || name === 'min') {
-    const chooseLeft = name === 'max' ? x >= y : x <= y;
+    const cmp = compareArithmeticValues(args[0], args[1]);
+    const chooseLeft = name === 'max' ? cmp >= 0 : cmp <= 0;
     return chooseLeft ? args[0] : args[1];
   }
   if (name === 'atan2') {
@@ -2435,12 +2437,33 @@ function numericTerm(value) {
 export function evaluateArithmetic(term, env) {
   return evaluate(term, env);
 }
+function compareIntegerToFloat(integerValue, floatValue) {
+  if (!Number.isFinite(floatValue)) throw new PrologError('evaluation_error(float_overflow)');
+
+  // Do not round an unbounded integer through JavaScript Number before a
+  // mixed arithmetic comparison.  Every integral IEEE-754 double can be
+  // converted back to the exact integer value it represents; fractional
+  // doubles necessarily have magnitude below 2^53, so their truncation is
+  // also exact.  This preserves mathematical ordering across the I/F boundary
+  // (STC #50), e.g. 9007199254740993 > 9007199254740992.0.
+  if (Number.isInteger(floatValue)) {
+    const floatInteger = BigInt(floatValue);
+    return integerValue < floatInteger ? -1 : integerValue > floatInteger ? 1 : 0;
+  }
+
+  const truncated = BigInt(Math.trunc(floatValue));
+  if (integerValue < truncated) return -1;
+  if (integerValue > truncated) return 1;
+  return floatValue > 0 ? -1 : 1;
+}
+
 export function compareArithmeticValues(left, right) {
   const a = left.value;
   const b = right.value;
-  return left.integer && right.integer
-    ? (a < b ? -1 : a > b ? 1 : 0)
-    : (Number(a) < Number(b) ? -1 : Number(a) > Number(b) ? 1 : 0);
+  if (left.integer && right.integer) return a < b ? -1 : a > b ? 1 : 0;
+  if (left.integer) return compareIntegerToFloat(a, b);
+  if (right.integer) return -compareIntegerToFloat(b, a);
+  return a < b ? -1 : a > b ? 1 : 0;
 }
 function* isBuiltin({ goal, env }) {
   const result = arithmeticValueTerm(evaluateArithmetic(goal.args[1], env));

package/src/write.js

@@ -143,6 +143,28 @@ 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());
@@ -286,7 +308,15 @@ function format(term, env, options, table, maxPriority = 1200, context = 'term')
       let text;
       if (specifier === 'fx' || specifier === 'fy') {
         const argumentPriority = specifier === 'fx' ? priority - 1 : priority;
-        text = `${token} ${format(resolved.args[0], env, options, table, argumentPriority)}`;
+        // 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)) {
+          text = `${token} (${format(resolved.args[0], env, options, table, 1200)})`;
+        } else {
+          text = `${token} ${format(resolved.args[0], env, options, table, argumentPriority)}`;
+        }
       } else if (specifier === 'xf' || specifier === 'yf') {
         let argumentPriority = specifier === 'xf' ? priority - 1 : priority;
         const childDefinition = chooseOperator(deref(resolved.args[0], env), table);

package/test/conformance/README.md

@@ -11,6 +11,9 @@ and proof output test the behavior of the JavaScript implementation.
 corrigenda, Part 2 modules, and Part 3 definite clause grammars to representative
 executable cases. [WG17-SYNTAX-STATUS.md](WG17-SYNTAX-STATUS.md) records the
 complete one-to-one trace for the vendored active upstream WG17 syntax cases.
+[STC-DRAFT-STATUS.md](STC-DRAFT-STATUS.md) separately tracks executable
+implementation questions from the post-N289 working draft; those cases are
+review evidence, not normative ISO claims.
 
 “Conformance” here means conformance to EyeProlog's documented ISO compatibility
 profile and implementation extensions. The default registry covers the exact
@@ -72,7 +75,7 @@ Run the Part 1 + Corrigenda strict-core processor gate:
 npm run test:iso-strict
 ```
 
-Run all vendored WG17 conformity matrices independently:
+Run the vendored WG17 conformity matrix independently:
 
 ```sh
 npm run test:wg17
@@ -87,12 +90,15 @@ npm run test:wg17
 ```
 
 `wg17:upgrade` reconciles the upstream inventory by identifier: unchanged cases
-keep their reviewed exact outcomes, removed cases disappear, and new or
-semantically changed cases are executed directly against the upstream Codex
-expectation. This means `npm run test:wg17` can test an upgraded snapshot
-immediately without first copying EyeProlog's current behaviour into an
-expected result. Normal `npm test` remains offline and uses only the committed
-snapshot.
+may keep their reviewed exact outcomes as an additional regression lock,
+removed cases disappear, and new or semantically changed cases initially have
+no local snapshot. **Every case is always checked independently against the
+upstream Codex expectation**, so a reviewed EyeProlog outcome can never make a
+non-conforming result pass (the failure mode that previously hid WG17 #227).
+The runner follows the upstream `read(G), G` input protocol, including the
+terminating newline, so stream-sensitive cases such as #270 and #271 exercise
+the characters left after `read/1`. Normal `npm test` remains offline and uses
+only the committed upstream snapshot.
 
 Summarize conformance coverage by category:
 
@@ -128,8 +134,9 @@ Selected cases are adapted from the ISO and standard-core suites of Logtalk,
 Scryer Prolog, Trealla Prolog, and SWI-Prolog. Their upstream identifiers and licenses
 are recorded in [THIRD_PARTY.md](THIRD_PARTY.md).
 
-The corpus has 386 cases in `iso/` and 791 file-based conformance cases in
-total. The separate strict-reader WG17 matrix has 366 executable dispositions.
+The corpus has 386 cases in `iso/` and 800 file-based conformance cases in
+total. Of those, 9 cases in `stc/` are explicitly labelled working-draft
+review evidence rather than normative ISO claims. The separate strict-reader WG17 matrix has 366 executable dispositions.
 The generated `conformance-report.md` is the authoritative source for current
 category totals. Together with regression, documentation-sync, API, example,
 and book-example checks, `npm test` is the release gate.

package/test/conformance/STC-DRAFT-STATUS.md

@@ -0,0 +1,62 @@
+# WG17 STC draft review status
+
+Source: [post-N289 draft for further technical corrigenda](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc)
+
+This file tracks implementation-relevant questions from the WG17 **working
+draft**. It is deliberately separate from the ISO/IEC 13211-1 conformance
+claim: an STC item is a proposal or defect report until WG17 adopts normative
+wording.
+
+The purpose of this ledger is practical. Where an STC item can be expressed as
+an executable Prolog observation, EyeProlog keeps a standards-facing case under
+`test/conformance/stc/` (or points to an existing strict/WG17 case) so discussion
+of the draft can expose implementation problems before they become release
+regressions.
+
+## Reviewed executable items
+
+| STC item | Topic | EyeProlog evidence / finding |
+| --- | --- | --- |
+| [#37](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#37) | `clause/2` variable identity | `stc/clause_variable_identity` verifies sharing between head and body is preserved. |
+| [#39](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#39) | negative-number syntax | Covered extensively by the upstream-first WG17 syntax matrix; unary-minus read-back discrepancies found by that matrix were fixed in v1.3.27. |
+| [#40](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#40) | inexact float representation | EyeProlog uses the host IEEE-754 binary64 value and requires written floats to read back to that same value. Input underflow is covered by `stc/float_underflow_input`. |
+| [#42](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#42) | integer-to-float conversion for float functions | `stc/integer_to_float_evaluable` verifies an integer expression is accepted by `sin/1` and produces a float. |
+| [#44](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#44) | `char_code/2` error classification | Existing strict conformance cases require `representation_error(character_code)` for an integer outside the character-code set. |
+| [#49](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#49) | `read_term/3` and EOF | Covered by strict reader/conformance tests and the interactive-read regressions. |
+| [#50](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#50) | mixed integer/float arithmetic comparison | **Found a bug during this audit.** EyeProlog rounded unbounded integers through JavaScript `Number`; `9007199254740993 > 9007199254740992.0` incorrectly failed. `stc/mixed_integer_float_comparison` now requires exact cross-type ordering and `max/2`/`min/2` use the same comparison. |
+| [#55](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#55) | integer rounding function | Existing flag conformance verifies `integer_rounding_function = toward_zero`. |
+| [#58](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#58) | `set_prolog_flag/2` instantiation error | Existing strict/error coverage requires an instantiation error when a required flag value is a variable. |
+| [#67](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#67) | `bagof/3` answer-order example | `stc/bagof_answer_order` verifies the proposed clarifying example produces `[2,1]`. |
+| [#73](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#73) | float-reading limits discussed from issue #54 | Positive/negative literal and `number_chars/2` overflow are kept as explicit draft cases; underflow is tested separately. See the note below. |
+
+## Float-reading note for #73
+
+EyeProlog currently has a finite-double numeric profile. The draft-facing cases
+record the behavior discussed in issue #54:
+
+- a positive finite numeric token beyond the representable range raises
+  `representation_error(max_float)`;
+- the corresponding negative overflow raises `representation_error(min_float)`;
+- input underflow may round to `0.0`;
+- overflow produced by arithmetic evaluation remains
+  `evaluation_error(float_overflow)`.
+
+These `max_float` / `min_float` names are treated as a **provisional draft
+extension**, not as a claim about the currently published ISO core standard.
+The earlier WG17 float-update material also uses
+`representation_error(float_overflow)` for unsupported infinity input, while a
+separate reading-floats proposal discusses `max_float` for a finite value above
+the implementation's largest finite float. Those cases should remain distinct
+when WG17 settles the wording.
+
+Relevant background:
+
+- [WG17 float update](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/core_update_float-2014-07-21)
+- [Issue #54](https://github.com/eyereasoner/eyeprolog/issues/54)
+
+## Maintenance rule
+
+When the STC draft changes, review executable changes before a release. Draft
+expectations must never silently replace the normative ISO/WG17 expectations;
+where the two differ, keep the draft test clearly labelled `stc/` until the
+standardization status changes.

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

@@ -4,9 +4,10 @@ Source: [Conformity Testing I: Syntax](https://www.complang.tuwien.ac.at/ulrich/
 Upstream inventory checked: 2026-08-16
 
 This ledger counts an upstream case when its WG17 identifier, query, and
-expected ISO disposition are stored in the offline executable matrix. Existing
-cases may pin an exact reviewed EyeProlog outcome; newly upgraded cases are
-executed directly against the upstream Codex expectation.
+expected ISO disposition are stored in the offline executable matrix. Every
+case is executed against the upstream Codex expectation. Reviewed exact
+EyeProlog outcomes are additional regression locks and can never override the
+upstream assertion.
 
 ## Current standing
 
@@ -19,8 +20,9 @@ executed directly against the upstream Codex expectation.
 
 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. 1 case uses the upstream Codex expectation directly; the remaining
-365 cases retain exact stored outcomes for stronger regression checking.
+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.
 
 ## Traceable evidence
 

package/test/conformance/cases/stc/bagof_answer_order.pl

@@ -0,0 +1,6 @@
+% STC #67: the clarifying bagof/3 example retains proof/answer order.
+% https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#67
+%% goal: bagof_answer_order
+
+bagof_answer_order :-
+  bagof(X, (X = 2 ; X = 1), [2, 1]).

package/test/conformance/cases/stc/clause_variable_identity.pl

@@ -0,0 +1,9 @@
+% STC #37: clause/2 must preserve sharing between variables in head and body.
+% https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#37
+%% goal: clause_variable_identity
+
+a(X) :- b(X).
+
+clause_variable_identity :-
+  clause(a(A), b(B)),
+  A == B.

package/test/conformance/cases/stc/float_underflow_input.pl

@@ -0,0 +1,10 @@
+% Float-reading draft review associated with STC #73 / issue #54. EyeProlog's
+% finite-double profile permits input underflow to round to zero.
+% https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#73
+%% goal: float_underflow_input
+
+float_underflow_input :-
+  number_chars(Positive, "1.0e-99999"),
+  Positive =:= 0.0,
+  number_chars(Negative, "-1.0e-99999"),
+  Negative =:= 0.0.

package/test/conformance/cases/stc/integer_to_float_evaluable.pl

@@ -0,0 +1,8 @@
+% STC #42: float evaluable functors such as sin/1 accept integer expressions
+% through the specified integer-to-float conversion.
+% https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#42
+%% goal: integer_to_float_evaluable
+
+integer_to_float_evaluable :-
+  X is sin(1),
+  float(X).

package/test/conformance/cases/stc/mixed_integer_float_comparison.pl

@@ -0,0 +1,16 @@
+% STC #50: mixed arithmetic comparisons must not become incorrect by rounding
+% an integer through the float representation before comparing it.
+% https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#50
+%% goal: mixed_integer_float_comparison
+
+mixed_integer_float_comparison :-
+  9007199254740993 > 9007199254740992.0,
+  9007199254740992.0 < 9007199254740993,
+  9007199254740993 =\= 9007199254740992.0,
+  -9007199254740993 < -9007199254740992.0,
+  Max is max(9007199254740993, 9007199254740992.0),
+  integer(Max),
+  Max =:= 9007199254740993,
+  Min is min(9007199254740993, 9007199254740992.0),
+  float(Min),
+  Min =:= 9007199254740992.0.

package/test/conformance/errors/stc/float_overflow_negative_literal.pl

@@ -0,0 +1,3 @@
+% Draft float-reading limit review associated with STC #73 / issue #54.
+% https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#73
+answer(-1.0e99999).

package/test/conformance/errors/stc/float_overflow_negative_number_chars.pl

@@ -0,0 +1,3 @@
+% Draft float-reading limit review associated with STC #73 / issue #54.
+% https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#73
+%% goal: number_chars(_, "-1.0e99999")

package/test/conformance/errors/stc/float_overflow_positive_literal.pl

@@ -0,0 +1,3 @@
+% Draft float-reading limit review associated with STC #73 / issue #54.
+% https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#73
+answer(1.0e99999).

package/test/conformance/errors/stc/float_overflow_positive_number_chars.pl

@@ -0,0 +1,3 @@
+% Draft float-reading limit review associated with STC #73 / issue #54.
+% https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#73
+%% goal: number_chars(_, "1.0e99999")

package/test/conformance/expected/stc/bagof_answer_order.pl

@@ -0,0 +1 @@
+bagof_answer_order.

package/test/conformance/expected/stc/clause_variable_identity.pl

@@ -0,0 +1 @@
+clause_variable_identity.

package/test/conformance/expected/stc/float_underflow_input.pl

@@ -0,0 +1 @@
+float_underflow_input.

package/test/conformance/expected/stc/integer_to_float_evaluable.pl

@@ -0,0 +1 @@
+integer_to_float_evaluable.

package/test/conformance/expected/stc/mixed_integer_float_comparison.pl

@@ -0,0 +1 @@
+mixed_integer_float_comparison.

package/test/conformance/expected-errors/stc/float_overflow_negative_literal.txt

@@ -0,0 +1 @@
+error(representation_error(min_float))

package/test/conformance/expected-errors/stc/float_overflow_negative_number_chars.txt

@@ -0,0 +1 @@
+error(representation_error(min_float))

package/test/conformance/expected-errors/stc/float_overflow_positive_literal.txt

@@ -0,0 +1 @@
+error(representation_error(max_float))

package/test/conformance/expected-errors/stc/float_overflow_positive_number_chars.txt

@@ -0,0 +1 @@
+error(representation_error(max_float))

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

@@ -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": "[]"
           }
         ]
@@ -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": "[]"
           }
         ]
@@ -3162,7 +3162,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "A",
+            "output": "$VAR(0)",
             "variables": "[]"
           }
         ]
@@ -5092,7 +5092,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "- (1 * 2) ^ 3",
+            "output": "- ((1 * 2) ^ 3)",
             "variables": "[]"
           }
         ]

package/test/run-regression.mjs

@@ -54,7 +54,7 @@ import { proofExamples } from './run-examples.mjs';
 import { goalsFromSource } from './goal-metadata.mjs';
 import { renderWg17SyntaxStatus } from '../tools/report-wg17-syntax-coverage.mjs';
 import { parseWg17SyntaxTable } from '../tools/upgrade-wg17.mjs';
-import { matchesUpstreamExpectation } from './run-wg17.mjs';
+import { executeWg17Item, matchesUpstreamExpectation, readWg17SyntaxFixture } from './run-wg17.mjs';
 
 const testRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)));
 const packageRoot = path.resolve(testRoot, '..');
@@ -849,6 +849,29 @@ c4 ?- call((!;1)).
         assertEqual(hostTermError?.formal, 'evaluation_error(float_overflow)', 'host-created non-finite term');
       },
     },
+    {
+      name: 'mixed integer/float arithmetic comparison preserves exact order (STC #50)',
+      run: () => {
+        const hugeInteger = `1${'0'.repeat(309)}`;
+        const program = `
+          check :-
+            9007199254740993 > 9007199254740992.0,
+            9007199254740992.0 < 9007199254740993,
+            9007199254740993 =\\= 9007199254740992.0,
+            -9007199254740993 < -9007199254740992.0,
+            ${hugeInteger} > 1.0e308,
+            -${hugeInteger} < -1.0e308,
+            Max is max(9007199254740993, 9007199254740992.0),
+            integer(Max),
+            Max =:= 9007199254740993,
+            Min is min(9007199254740993, 9007199254740992.0),
+            float(Min),
+            Min =:= 9007199254740992.0.
+        `;
+        const result = runEyeProlog(program, { goal: 'check' });
+        assertEqual(result.stdout, 'check.\n', 'mixed integer/float ordering');
+      },
+    },
     {
       name: 'readers keep a full stop inside a character-code constant (WG17 #367)',
       run: () => {
@@ -3236,7 +3259,7 @@ function documentationSyncCases() {
       },
     },
     {
-      name: 'WG17 direct upstream assertions are executable without local outcomes',
+      name: 'WG17 upstream expectations independently validate reviewed outcomes',
       run: () => {
         assertEqual(matchesUpstreamExpectation('succeeds', { type: 'success', stages: [] }), true, 'succeeds');
         assertEqual(matchesUpstreamExpectation('fails', { type: 'failure' }), true, 'fails');
@@ -3251,6 +3274,39 @@ function documentationSyncCases() {
           true,
           'observable output',
         );
+        const repeated = {
+          id: 227, input: 'write_canonical(B+B).',
+          outcome: { type: 'success', stages: [{ output: '+(_A,_A)', variables: "['B' = B]" }] },
+        };
+        assertEqual(
+          matchesUpstreamExpectation('e.g. +(_1,_1)', repeated.outcome, repeated),
+          true,
+          'anonymous spelling accepted',
+        );
+        assertEqual(
+          matchesUpstreamExpectation(
+            'e.g. +(_1,_1)',
+            { type: 'success', stages: [{ output: '+(B,B)', variables: "['B' = B]" }] },
+            repeated,
+          ),
+          false,
+          'named-variable spelling rejected',
+        );
+      },
+    },
+    {
+      name: 'WG17 stream-sensitive cases #270 and #271 follow the upstream input protocol',
+      run: () => {
+        const fixture = readWg17SyntaxFixture();
+        const byId = new Map(fixture.cases.map((item) => [item.id, item]));
+        for (const [id, expected] of [[270, "C = ' '"], [271, "C = '%'"]]) {
+          const item = byId.get(id);
+          if (item == null) throw new Error(`missing WG17 #${id}`);
+          assertEqual(item.expected, expected, `WG17 #${id} upstream expectation`);
+          const actual = executeWg17Item(item);
+          assertEqual(matchesUpstreamExpectation(item.expected, actual, item), true, `WG17 #${id} result`);
+          assertEqual(JSON.stringify(actual), JSON.stringify(item.outcome), `WG17 #${id} reviewed outcome`);
+        }
       },
     },
     {

package/test/run-wg17.mjs

@@ -1,13 +1,16 @@
 #!/usr/bin/env node
-// Aggregate all vendored WG17 conformity suites behind one stable entry point.
-// The current upstream conformity table is syntax-focused; additional WG17
-// suites can be added here without changing npm/CI commands.
+// Offline execution of the vendored WG17 conformity-testing syntax matrix.
+// Every case is checked against the upstream Codex expectation. Reviewed
+// exact EyeProlog outcomes are an additional regression lock, never a
+// replacement for the upstream assertion.
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import {
   Env, Program, Solver, parseGoalText, run,
 } from '../src/index.js';
+import { parseTermText } from '../src/parser.js';
+import { variantTerms } from '../src/term.js';
 import { TestReporter, isMainModule } from './test-style.mjs';
 
 const testRoot = path.dirname(fileURLToPath(import.meta.url));
@@ -32,6 +35,9 @@ function capturedStages(stdout) {
 
 function executeFinite(item) {
   try {
+    // Match the upstream protocol: the Query cell plus its terminating newline
+    // is input to read(G), G (and subsequent read/call stages when present).
+    // This is essential for stream-sensitive cases such as #270 and #271.
     const result = run('', {
       isoStrict: true,
       goal: runnerStage(1, item.readCount ?? 16),
@@ -48,7 +54,7 @@ function executeWait(item) {
   const program = Program.parse('', { isoStrict: true });
   const solver = new Solver(program, {
     isoStrict: true,
-    ioOptions: { input: item.input },
+    ioOptions: { input: `${item.input}\n` },
   });
   const stream = solver.io.resolve('user_input');
   let requests = 0;
@@ -63,32 +69,203 @@ function executeWait(item) {
   try {
     [...solver.solve([goal], new Env(), 0)];
   } catch (_) {
-    // Returning null from the hook models EOF after EyeProlog has asked the
-    // interactive source for the continuation that the upstream case awaits.
+    // Returning null models EOF only after EyeProlog has requested the extra
+    // input that the upstream case classifies as "waits".
   }
   return requests === 1 ? { type: 'waits' } : { type: 'did_not_wait', requests };
 }
 
-function canonicalUpstreamExpected(expected) {
-  return String(expected)
+function presentationText(value) {
+  return String(value ?? '')
+    .replace(/&sup[23];/gi, '')
     .replace(/[²³°]/g, '')
     .replace(/\u00a0/g, ' ')
-    .replace(/[ \t\n]+/g, ' ')
+    .replace(/\r\n?/g, '\n')
     .trim();
 }
 
-function observableOutput(actual) {
-  if (actual.type !== 'success') return null;
-  return actual.stages.map(({ output }) => output).join('');
+function canonicalUpstreamExpected(expected) {
+  return presentationText(expected).replace(/[ \t\n]+/g, ' ').trim();
+}
+
+function bindingAnswer(text) {
+  let value = String(text ?? '').trim();
+  if (value === '[]') return '';
+  if (value.startsWith('[') && value.endsWith(']')) value = value.slice(1, -1);
+  return value.replace(/'([A-Z_][A-Za-z0-9_]*)'\s*=/g, '$1 =');
+}
+
+function observableCandidates(actual) {
+  if (actual.type !== 'success') return [];
+  const outputs = actual.stages.map(({ output }) => output ?? '').filter(Boolean);
+  const bindings = actual.stages.map(({ variables }) => bindingAnswer(variables)).filter(Boolean);
+  const candidates = new Set([...outputs, ...bindings]);
+  if (outputs.length > 0) {
+    candidates.add(outputs.join(''));
+    candidates.add(outputs.join(' '));
+  }
+  if (bindings.length > 0) candidates.add(bindings.join(', '));
+  if (outputs.length > 0 && bindings.length > 0) {
+    candidates.add([...outputs, ...bindings].join(' '));
+    candidates.add(`${outputs.join('')} ${bindings.join(', ')}`);
+  }
+  return [...candidates].filter(Boolean);
+}
+
+function stripLayoutOutsideQuotes(text) {
+  const source = presentationText(text);
+  let output = '';
+  let quote = null;
+  for (let index = 0; index < source.length; index++) {
+    const ch = source[index];
+    if (quote != null) {
+      output += ch;
+      if (ch === '\\' && index + 1 < source.length) {
+        output += source[++index];
+        continue;
+      }
+      if (ch === quote) {
+        if (source[index + 1] === quote) output += source[++index];
+        else quote = null;
+      }
+      continue;
+    }
+    if (ch === "'" || ch === '"' || ch === '`') {
+      quote = ch;
+      output += ch;
+    } else if (!/\s/.test(ch)) {
+      output += ch;
+    }
+  }
+  return output.replace(/\.$/, '').replace(/([eE])\+(?=\d)/g, '$1');
+}
+
+function normalizeExampleVariables(text) {
+  const names = new Map();
+  let next = 0;
+  return String(text).replace(/(?<![A-Za-z0-9_])_[A-Za-z0-9]+/g, (name) => {
+    if (!names.has(name)) names.set(name, `_V${++next}`);
+    return names.get(name);
+  });
+}
+
+function unquoteAtomText(text) {
+  const source = text.trim();
+  if (!(source.startsWith("'") && source.endsWith("'"))) return source;
+  let output = '';
+  for (let index = 1; index < source.length - 1; index++) {
+    const ch = source[index];
+    if (ch === "'" && source[index + 1] === "'") {
+      output += "'";
+      index++;
+      continue;
+    }
+    if (ch === '\\' && index + 1 < source.length - 1) {
+      const escaped = source[++index];
+      const symbolic = { a: '\x07', b: '\b', f: '\f', n: '\n', r: '\r', t: '\t', v: '\v' };
+      output += symbolic[escaped] ?? escaped;
+      continue;
+    }
+    output += ch;
+  }
+  return output;
+}
+
+function splitOperatorNames(text) {
+  const source = text.trim();
+  if (!source.startsWith('[')) return [unquoteAtomText(source)];
+  const body = source.slice(1, -1);
+  const names = [];
+  let quote = false;
+  let start = 0;
+  for (let index = 0; index <= body.length; index++) {
+    const ch = body[index];
+    if (quote) {
+      if (ch === "'" && body[index + 1] === "'") index++;
+      else if (ch === "'") quote = false;
+      continue;
+    }
+    if (ch === "'") {
+      quote = true;
+      continue;
+    }
+    if (ch === ',' || index === body.length) {
+      names.push(unquoteAtomText(body.slice(start, index)));
+      start = index + 1;
+    }
+  }
+  return names.filter(Boolean);
+}
+
+function operatorDefinitionsFromInput(input) {
+  const definitions = [];
+  const pattern = /\bop\(\s*(\d+)\s*,\s*(fx|fy|xf|yf|xfx|xfy|yfx)\s*,\s*(\[[^\]]*\]|'(?:''|[^'])*'|[^)\s,]+)\s*\)/g;
+  for (const match of String(input ?? '').matchAll(pattern)) {
+    for (const name of splitOperatorNames(match[3])) {
+      definitions.push([Number(match[1]), match[2], name]);
+    }
+  }
+  return definitions;
+}
+
+function termEquivalent(expected, actual, item) {
+  try {
+    const operatorDefinitions = operatorDefinitionsFromInput(item?.input);
+    const options = { isoStrict: true, operatorDefinitions };
+    const left = parseTermText(`${presentationText(expected).replace(/\.$/, '')}.`, options);
+    const right = parseTermText(`${presentationText(actual).replace(/\.$/, '')}.`, options);
+    return variantTerms(left, new Env(), right, new Env());
+  } catch (_) {
+    return false;
+  }
+}
+
+function abbreviatedErrorMatches(expected, actual) {
+  if (actual.type !== 'error') return false;
+  const formal = actual.formal ?? '';
+  const patterns = [
+    [/p\._e\./i, 'permission_error'],
+    [/d\._e\./i, 'domain_error'],
+    [/ex\._e\./i, 'existence_error'],
+    [/rep(?:r)?\._e\.|repr\.\s*err\./i, 'representation_error'],
+  ];
+  return patterns.some(([pattern, prefix]) => pattern.test(expected) && formal.startsWith(prefix));
 }
 
-export function matchesUpstreamExpectation(expectedText, actual) {
+function textExpectationMatches(expectedText, actual, item, example = false) {
+  const candidates = observableCandidates(actual);
+  if (candidates.length === 0) return false;
+  let expected = presentationText(expectedText);
+  if (example) expected = expected.replace(/^e\.g\.\s*/i, '');
+
+  for (const candidate of candidates) {
+    let left = expected;
+    let right = candidate;
+    if (example && /(?<![A-Za-z0-9_])_[A-Za-z0-9]+/.test(left)) {
+      // ISO 7.10.5 requires the generated spelling to be an anonymous-variable
+      // token. Normalise only the choice of suffix/name, not the leading `_`.
+      if (!/(?<![A-Za-z0-9_])_[A-Za-z0-9]+/.test(right)) continue;
+      left = normalizeExampleVariables(left);
+      right = normalizeExampleVariables(right);
+    }
+    if (stripLayoutOutsideQuotes(left) === stripLayoutOutsideQuotes(right)) return true;
+    if (termEquivalent(left, right, item)) return true;
+    if (example) {
+      const expectedNumber = Number(left);
+      const actualNumber = Number(right);
+      if (Number.isFinite(expectedNumber) && Number.isFinite(actualNumber) &&
+          Object.is(expectedNumber, actualNumber)) return true;
+    }
+  }
+  return false;
+}
+
+export function matchesUpstreamExpectation(expectedText, actual, item = {}) {
   const expected = canonicalUpstreamExpected(expectedText);
 
   if (/^waits$/i.test(expected)) return actual.type === 'waits';
   if (/^succeeds(?:\b|$)/i.test(expected)) return actual.type === 'success';
   if (/^fails(?:\b|$)/i.test(expected)) return actual.type === 'failure';
-
   if (/^syntax\s*err\.?$/i.test(expected)) {
     return actual.type === 'error' && /^syntax_error\(/.test(actual.formal ?? '');
   }
@@ -96,26 +273,24 @@ export function matchesUpstreamExpectation(expectedText, actual) {
     return actual.type === 'error' && /^representation_error\(/.test(actual.formal ?? '');
   }
   if (/^syntax\/repr\.\s*err\.?$/i.test(expected)) {
-    return actual.type === 'error' &&
-      /^(?:syntax_error|representation_error)\(/.test(actual.formal ?? '');
+    return actual.type === 'error' && /^(?:syntax_error|representation_error)\(/.test(actual.formal ?? '');
   }
   if (/^syntax\s*err\.\/waits$/i.test(expected)) {
     return actual.type === 'waits' ||
       (actual.type === 'error' && /^syntax_error\(/.test(actual.formal ?? ''));
   }
+  if (abbreviatedErrorMatches(expected, actual)) return true;
 
-  // Most new WG17 rows are observable write/read examples.  For those, the
-  // Codex cell itself is the expected output, so no hand-written local
-  // outcome is needed before the case can be executed.
-  const output = observableOutput(actual);
-  if (output != null && canonicalUpstreamExpected(output) === expected) return true;
-
-  return false;
+  if (/\s+or\s+/i.test(expected)) {
+    return expected.split(/\s+or\s+/i)
+      .some((alternative) => matchesUpstreamExpectation(alternative, actual, item));
+  }
+  if (/^e\.g\.\s*/i.test(expected)) return textExpectationMatches(expected, actual, item, true);
+  return textExpectationMatches(expected, actual, item, false);
 }
 
 function usesWaitMatcher(expectedText) {
-  const expected = canonicalUpstreamExpected(expectedText);
-  return /^waits$/i.test(expected);
+  return /^waits$/i.test(canonicalUpstreamExpected(expectedText));
 }
 
 function compactTestText(value, maximum) {
@@ -135,30 +310,34 @@ export function wg17TestDescription(item) {
   return `#${item.id} ${query} -> ${expected}`;
 }
 
+export function executeWg17Item(item) {
+  return usesWaitMatcher(item.expected) || item.outcome?.type === 'waits'
+    ? executeWait(item)
+    : executeFinite(item);
+}
+
 function assertOutcome(item) {
-  if (item.outcome != null) {
-    const actual = item.outcome.type === 'waits' ? executeWait(item) : executeFinite(item);
-    if (JSON.stringify(actual) !== JSON.stringify(item.outcome)) {
-      throw new Error(
-        `WG17 #${item.id} (${item.expected})\n` +
-        `expected ${JSON.stringify(item.outcome)}\n` +
-        `actual   ${JSON.stringify(actual)}`,
-      );
-    }
-    return;
-  }
+  const actual = executeWg17Item(item);
 
-  const actual = usesWaitMatcher(item.expected) ? executeWait(item) : executeFinite(item);
-  if (!matchesUpstreamExpectation(item.expected, actual)) {
+  if (!matchesUpstreamExpectation(item.expected, actual, item)) {
     throw new Error(
       `WG17 #${item.id} (${item.expected})\n` +
-      `upstream expectation did not match\n` +
+      `upstream Codex expectation did not match\n` +
       `actual ${JSON.stringify(actual)}`,
     );
   }
+
+  if (item.outcome != null && JSON.stringify(actual) !== JSON.stringify(item.outcome)) {
+    throw new Error(
+      `WG17 #${item.id} (${item.expected})\n` +
+      `reviewed regression outcome changed\n` +
+      `expected ${JSON.stringify(item.outcome)}\n` +
+      `actual   ${JSON.stringify(actual)}`,
+    );
+  }
 }
 
-function readWg17SyntaxFixture() {
+export function readWg17SyntaxFixture() {
   const fixture = JSON.parse(fs.readFileSync(fixturePath, 'utf8'));
   if (!Array.isArray(fixture.cases) || fixture.cases.length === 0) {
     throw new Error('WG17 syntax fixture has no cases');
@@ -168,6 +347,16 @@ function readWg17SyntaxFixture() {
     if (!Number.isInteger(item.id) || ids.has(item.id)) {
       throw new Error(`invalid or duplicate WG17 syntax id #${item.id}`);
     }
+    if (typeof item.query !== 'string' || typeof item.input !== 'string' || typeof item.expected !== 'string') {
+      throw new Error(`incomplete WG17 syntax fixture row #${item.id}`);
+    }
+    if (item.outcome != null && !matchesUpstreamExpectation(item.expected, item.outcome, item)) {
+      throw new Error(
+        `WG17 #${item.id} reviewed outcome contradicts upstream Codex expectation\n` +
+        `upstream ${JSON.stringify(item.expected)}\n` +
+        `outcome  ${JSON.stringify(item.outcome)}`,
+      );
+    }
     ids.add(item.id);
   }
   return fixture;
@@ -183,10 +372,8 @@ function runWg17Syntax(reporter = new TestReporter()) {
   reporter.sectionTotal('WG17 syntax');
 }
 
-const suites = [runWg17Syntax];
-
 export function runWg17(reporter = new TestReporter()) {
-  for (const runSuite of suites) runSuite(reporter);
+  runWg17Syntax(reporter);
 }
 
 if (isMainModule(import.meta.url)) {

package/the-art-of-eyeprolog.md

@@ -7414,7 +7414,7 @@ upstream syntax cases. Reviewed cases can pin exact strict-reader outcomes, whil
 newly upgraded cases execute directly against the upstream Codex expectation.
 
 The complete suite must pass before release. The file-based conformance corpus
-contains 791 cases, including 386 focused ISO
+contains 800 cases, including 386 focused ISO
 cases derived from the success, failure, mode, and error behavior in
 ISO/IEC 13211-1 clauses 7 and 8, Part 2 modules, and Part 3 grammar rules.
 Separate exact-output suites check 210 normal

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

@@ -92,9 +92,10 @@ Source: [Conformity Testing I: Syntax](${manifest.source})
 Upstream inventory checked: ${manifest.checkedOn}
 
 This ledger counts an upstream case when its WG17 identifier, query, and
-expected ISO disposition are stored in the offline executable matrix. Existing
-cases may pin an exact reviewed EyeProlog outcome; newly upgraded cases are
-executed directly against the upstream Codex expectation.
+expected ISO disposition are stored in the offline executable matrix. Every
+case is executed against the upstream Codex expectation. Reviewed exact
+EyeProlog outcomes are additional regression locks and can never override the
+upstream assertion.
 
 ## Current standing
 
@@ -107,8 +108,9 @@ executed directly against the upstream Codex expectation.
 
 The matrix runs in strict ISO stream-reader mode as part of \`npm test\`. The
 ${waits} upstream \`waits\` case${waits === 1 ? '' : 's'} ${waits === 1 ? 'is' : 'are'} checked through EyeProlog's interactive input
-hook. ${direct} case${direct === 1 ? '' : 's'} use${direct === 1 ? 's' : ''} the upstream Codex expectation directly; the remaining
-${coveredIds.length - direct} case${coveredIds.length - direct === 1 ? '' : 's'} retain exact stored outcomes for stronger regression checking.
+hook. All ${coveredIds.length} executable cases are independently checked against the
+upstream Codex expectation. ${coveredIds.length - direct} case${coveredIds.length - direct === 1 ? '' : 's'} additionally retain exact reviewed
+outcomes for stronger regression checking; ${direct} case${direct === 1 ? '' : 's'} currently ${direct === 1 ? 'relies' : 'rely'} on the upstream assertion alone.
 
 ## Traceable evidence
 

package/tools/upgrade-wg17.mjs

@@ -364,7 +364,7 @@ function printHelp() {
   process.stdout.write(`Usage: npm run wg17:upgrade -- [--check] [--source URL_OR_FILE]\n\n` +
     `Refreshes the vendored WG17 conformity tests from the TU Wien table.\n` +
     `New or changed rows are executable immediately against the upstream\n` +
-    `Codex expectation; existing reviewed exact outcomes remain pinned.\n`);
+    `Codex expectation; existing reviewed exact outcomes remain pinned only as additional regression checks.\n`);
 }
 
 export async function upgradeWg17({ check = false, source = syntaxSource } = {}) {

package/test/run-wg17-syntax.mjs

@@ -1,106 +0,0 @@
-#!/usr/bin/env node
-// Offline, one-by-one execution of the 366 active WG17 syntax cases. The
-// fixture is a dated snapshot of the public conformity-testing table, so the
-// release gate does not depend on the network or another Prolog system.
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import {
-  Env, Program, Solver, parseGoalText, run,
-} from '../src/index.js';
-import { TestReporter, isMainModule } from './test-style.mjs';
-
-const testRoot = path.dirname(fileURLToPath(import.meta.url));
-const fixturePath = path.join(testRoot, 'conformance', 'wg17-syntax-cases.json');
-
-function runnerStage(index, maximum) {
-  if (index > maximum) return `write('\\n<WG17-COMPLETE>')`;
-  return `read_term(G${index}, [variable_names(V${index})]), ` +
-    `(G${index} == end_of_file -> write('\\n<WG17-COMPLETE>') ; (` +
-    `write('\\n<WG17-BEGIN-${index}>'), call(G${index}), ` +
-    `write('<WG17-VARS>'), writeq(V${index}), write('<WG17-END>'), ` +
-    `${runnerStage(index + 1, maximum)}))`;
-}
-
-function capturedStages(stdout) {
-  const complete = stdout.indexOf('<WG17-COMPLETE>');
-  if (complete < 0) return null;
-  const captured = stdout.slice(0, complete);
-  return [...captured.matchAll(/<WG17-BEGIN-(\d+)>([\s\S]*?)<WG17-VARS>([\s\S]*?)<WG17-END>/g)]
-    .map((match) => ({ output: match[2], variables: match[3] }));
-}
-
-function executeFinite(item) {
-  try {
-    const result = run('', {
-      isoStrict: true,
-      goal: runnerStage(1, item.readCount),
-      ioOptions: { input: `${item.input}\n` },
-    });
-    const stages = capturedStages(result.stdout);
-    return stages == null ? { type: 'failure' } : { type: 'success', stages };
-  } catch (error) {
-    return { type: 'error', formal: error?.formal ?? null };
-  }
-}
-
-function executeWait(item) {
-  const program = Program.parse('', { isoStrict: true });
-  const solver = new Solver(program, {
-    isoStrict: true,
-    ioOptions: { input: item.input },
-  });
-  const stream = solver.io.resolve('user_input');
-  let requests = 0;
-  stream.interactiveReadTerm = () => {
-    requests++;
-    return null;
-  };
-  const goal = parseGoalText('read_term(G, [])', {
-    isoStrict: true,
-    operatorDefinitions: [...program.operators.values()],
-  });
-  try {
-    [...solver.solve([goal], new Env(), 0)];
-  } catch (_) {
-    // Returning null from the hook models EOF after EyeProlog has asked the
-    // interactive source for the continuation that the upstream case awaits.
-  }
-  return requests === 1 ? { type: 'waits' } : { type: 'did_not_wait', requests };
-}
-
-function assertOutcome(item) {
-  const actual = item.outcome.type === 'waits' ? executeWait(item) : executeFinite(item);
-  if (JSON.stringify(actual) !== JSON.stringify(item.outcome)) {
-    throw new Error(
-      `WG17 #${item.id} (${item.expected})\n` +
-      `expected ${JSON.stringify(item.outcome)}\n` +
-      `actual   ${JSON.stringify(actual)}`,
-    );
-  }
-}
-
-export function runWg17Syntax(reporter = new TestReporter()) {
-  const fixture = JSON.parse(fs.readFileSync(fixturePath, 'utf8'));
-  if (fixture.cases.length !== 366) {
-    throw new Error(`WG17 fixture has ${fixture.cases.length} cases instead of 366`);
-  }
-  const ids = new Set(fixture.cases.map(({ id }) => id));
-  if (ids.size !== 366 || ids.has(20) || ids.has(273)) {
-    throw new Error('WG17 fixture identifiers do not match the active upstream inventory');
-  }
-
-  reporter.section('WG17 syntax');
-  for (const item of fixture.cases) reporter.test(`#${item.id}`, () => assertOutcome(item));
-  reporter.sectionTotal('WG17 syntax');
-}
-
-if (isMainModule(import.meta.url)) {
-  const reporter = new TestReporter();
-  try {
-    runWg17Syntax(reporter);
-    reporter.totalLine();
-  } catch (_) {
-    process.exitCode = 1;
-  }
-}