eyeprolog 1.3.56 → 1.3.58

package/README.md

@@ -228,7 +228,13 @@ ongoing issue #65 audit additionally tightens Prolog-text declaration ordering,
 initialization lifetime, stream/open/close behavior, character/byte stream
 errors, `keysort/2` error cases, and strict arithmetic-extension boundaries.
 Those additions improve the Part 1 surface without turning the remaining audit
-rows into a blanket conformance claim.
+rows into a blanket conformance claim. The post-N289 WG17/STC working draft is
+reviewed separately rather than treated as a fourth Corrigendum. The
+2026-08-23 draft items #73-#76 are now pinned explicitly: float input limits for
+`read*` and `number_*` conversions, invalid-character term input, and the draft
+proposal that would make the two power-underflow rows depend on the processor's
+9.1.4.2 `resultF` choice. Strict mode retains the published Part 1 +
+Corrigenda 1-3 behavior where the draft has not been standardized.
 
 The auditable processor-requirement checklist lives in
 [`test/conformance/ISO-COMPLIANCE.md`](test/conformance/ISO-COMPLIANCE.md).

package/conformance-report.md

@@ -18,10 +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 |
+| stc | 5 | 6 | 0 | 0 | 11 |
 | 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** | **490** | **270** | **19** | **21** | **800** |
+| **Total** | **490** | **272** | **19** | **21** | **802** |

package/package.json

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

package/src/iso.js

@@ -393,9 +393,9 @@ function* functorBuiltin({ goal, env }) {
 
   const name = deref(goal.args[1], env);
   const arityTerm = deref(goal.args[2], env);
-  // ISO 8.5.1.3 orders construction-mode diagnostics. A compound Name is an
-  // atomic type error (before an Arity type error); only an atomic non-atom
-  // used for positive arity receives type_error(atom,...).
+  // Keep EyeProlog's deterministic construction-mode diagnostics aligned with
+  // the individual 8.5.1.3 conditions. Under 7.12, a call satisfying several
+  // error conditions at once does not acquire a globally mandated table order.
   if (name.type === VAR) throw new PrologError('instantiation_error');
   if (arityTerm.type === VAR) throw new PrologError('instantiation_error');
   if (name.type === COMPOUND) throw new PrologError('type_error(atomic)', name);
@@ -562,7 +562,9 @@ function* clauseBuiltin({ solver, goal, env }) {
   if (head.type !== ATOM && head.type !== COMPOUND) throw new PrologError('type_error(callable)', head);
   const indicator = compound('/', [atom(head.name), numberTerm(head.arity)]);
   const group = solver.program.findGroup(head.name, head.arity, head.module ?? goal.module ?? 'user');
-  // ISO 8.8.1.3 places private-procedure access before Body callability.
+  // EyeProlog selects private-procedure access before Body callability when both
+  // conditions hold. ISO 7.12 permits an implementation-dependent choice when
+  // more than one error condition is simultaneously satisfied.
   if (isProcessorStaticProcedure(solver, head) ||
       (solver.isoStrict && group && !group.dynamic)) {
     throw new PrologError('permission_error(access, private_procedure)', indicator);
@@ -590,7 +592,7 @@ function requireClauseHead(head) {
   if (head.type !== ATOM && head.type !== COMPOUND) throw new PrologError('type_error(callable)', head);
 }
 
-function convertAssertedBody(term, culprit = term) {
+export function convertClauseBodyTerm(term, culprit = term) {
   if (term.type === VAR) return compound('call', [term]);
   // ISO 7.6.2 converts each argument of conjunction, disjunction, and if-then
   // recursively when a term is converted to a clause body. This matters for
@@ -599,8 +601,8 @@ function convertAssertedBody(term, culprit = term) {
   // being stored and failing only if that branch is later executed.
   if (term.type === COMPOUND && [',', ';', '->'].includes(term.name) && term.arity === 2) {
     return compound(term.name, [
-      convertAssertedBody(term.args[0], culprit),
-      convertAssertedBody(term.args[1], culprit),
+      convertClauseBodyTerm(term.args[0], culprit),
+      convertClauseBodyTerm(term.args[1], culprit),
     ]);
   }
   if (term.type !== ATOM && term.type !== COMPOUND) {
@@ -643,7 +645,7 @@ function assertBuiltin(atStart) {
   return function* ({ solver, goal, env }) {
     const parts = clauseParts(goal.args[0], env);
     requireClauseHead(parts.head);
-    const body = convertAssertedBody(parts.body);
+    const body = convertClauseBodyTerm(parts.body);
     assertModifiable(solver, parts.head, goal.module ?? 'user');
     const copied = freshCopy(compound('$clause', [parts.head, body]), env);
     solver.program.insertDynamicClause({
@@ -782,9 +784,9 @@ function* opBuiltin({ solver, goal, env }) {
   const priorityTerm = deref(goal.args[0], env);
   const specifierTerm = deref(goal.args[1], env);
 
-  // ISO 8.14.3.3 prescribes the ordering below.  In particular, all three
-  // instantiation cases precede type/domain errors, and Operator list-shape
-  // errors precede priority/specifier domain errors.
+  // Keep EyeProlog's selected 8.14.3.3 overlap order deterministic. Each
+  // individual condition remains observable; ISO 7.12 leaves the choice
+  // implementation dependent when several error conditions hold at once.
   if (priorityTerm.type === VAR) throw new PrologError('instantiation_error');
   if (specifierTerm.type === VAR) throw new PrologError('instantiation_error');
   const operator = opListPreflight(goal.args[2], env);
@@ -943,12 +945,11 @@ function optionList(term, env) {
   return items.map((item) => deref(item, env));
 }
 
-// read_term/3 and write_term/3 have prescribed error ordering in ISO 8.14.
-// In particular, a partial option list (or a variable option element) is
-// diagnosed before several stream errors, while the relative order of a
-// non-list Options term and an invalid stream-or-alias differs between the
-// read and write predicates.  Split list-shape inspection from full option
-// validation so those predicates can follow the standard order exactly.
+// Keep read_term/3 and write_term/3 diagnostics deterministic and make every
+// 8.14 error condition independently testable. ISO 7.12 leaves the choice
+// implementation dependent when several error conditions hold simultaneously,
+// so this preflight order is an EyeProlog processor choice rather than a claim
+// that the textual order of an error table is globally mandatory.
 function preflightOptionList(term, env) {
   const value = deref(term, env);
   if (value.type === VAR) throw new PrologError('instantiation_error');
@@ -1017,9 +1018,9 @@ function* openBuiltin({ solver, goal, env }) {
   const streamTarget = deref(goal.args[2], env);
   const optionTerm = goal.arity === 3 ? emptyList() : goal.args[3];
 
-  // ISO 8.11.5.3 + Corrigenda 2/3.  Keep each prescribed condition
-  // observable on its own and apply the published ordering for deterministic
-  // diagnostics when several arguments are erroneous.
+  // ISO 8.11.5.3 + Corrigenda 2/3. Keep each required condition observable
+  // on its own. When several conditions hold, the order below is EyeProlog's
+  // deterministic 7.12 processor choice unless a procedural rule constrains it.
   if (source.type === VAR) throw new PrologError('instantiation_error');
   if (mode.type === VAR) throw new PrologError('instantiation_error');
   const preflight = preflightOptionList(optionTerm, env);
@@ -1183,16 +1184,21 @@ function isStreamPropertyPattern(value) {
 function* streamPropertyBuiltin({ solver, goal, env }) {
   const reference = deref(goal.args[0], env);
   const propertyPattern = deref(goal.args[1], env);
+  let fixedStreamId = null;
   if (reference.type !== VAR) {
-    const id = streamTermReference(goal.args[0], env);
-    if (!solver.io.resolve(id)) throw new PrologError('domain_error(stream)', reference);
+    // 8.11.8.1 enumerates (Stream, Property) pairs for currently open
+    // streams. A ground term with the implementation's stream-term shape is
+    // still a stream-term even when its stream is no longer open; in that
+    // case the enumeration simply has no matching pair. domain_error(stream)
+    // is reserved for a term which is not a stream-term at all.
+    fixedStreamId = streamTermReference(goal.args[0], env);
   }
   if (!isStreamPropertyPattern(propertyPattern)) {
     throw new PrologError('domain_error(stream_property)', propertyPattern);
   }
   const streams = reference.type === VAR
     ? [...solver.io.streams.values()]
-    : [solver.io.resolve(streamTermReference(goal.args[0], env))];
+    : [solver.io.resolve(fixedStreamId)].filter(Boolean);
   for (const stream of streams) {
     for (const property of streamProperties(stream)) {
       const next = env.clone();
@@ -1232,11 +1238,10 @@ function preflightInputUnitTarget(name, target, env, solver) {
       throw new PrologError('type_error(in_character)', value);
     }
   } else if (name.endsWith('code')) {
-    // ISO 8.12.1.3/8.12.2.3 puts the integer type check before stream
-    // diagnostics, but the integer-is-not-an-in-character-code
-    // representation error comes after the stream existence/mode/type/EOF
-    // conditions.  Defer that range/repertoire check until the input entity
-    // itself has been inspected below.
+    // Keep the selected 8.12 overlap behavior stable: integer type validation
+    // is done here, while the in-character-code repertoire check is deferred
+    // until after stream/entity diagnostics. ISO 7.12 permits this processor
+    // choice when those error conditions overlap.
     if (value.type !== VAR && (value.type !== NUMBER || !isDecimalInteger(value.name))) {
       throw new PrologError('type_error(integer)', value);
     }
@@ -1290,10 +1295,9 @@ function inputUnitBuiltin(name) {
     if (!binary && unit != null && solver.isoStrict && !isStrictIsoPcsCharacter(unit)) {
       throw new PrologError('representation_error(character)');
     }
-    // For get_code/peek_code the published error table places an invalid
-    // in-character-code target after stream and input-entity errors.  Doing
-    // this here prevents a fixed bad Code from masking (for example) an
-    // output-stream, binary-stream, past-EOF, or invalid-character error.
+    // EyeProlog deliberately defers this representation check until after
+    // stream and input-entity diagnostics. ISO 7.12 permits that deterministic
+    // choice when several 8.12 error conditions hold simultaneously.
     const targetValue = deref(target, env);
     if (name.endsWith('code') && targetValue.type !== VAR &&
         !validStrictInputCharacterCode(targetValue, solver)) {
@@ -1596,9 +1600,9 @@ function* readTermBuiltin({ solver, goal, env }) {
   const optionTerm = goal.args[goal.arity - 1];
   const streamTerm = goal.arity === 3 ? deref(goal.args[0], env) : null;
 
-  // ISO 8.14.1.3 error order:
-  // a) variable stream; b) partial/options-variable; c) bad stream-or-alias;
-  // d) non-list options; e) invalid read option; then stream existence/mode.
+  // EyeProlog's selected 8.14.1.3 overlap order. Each listed error condition
+  // is covered independently; 7.12 makes simultaneous-error selection
+  // implementation dependent unless another procedural requirement constrains it.
   if (streamTerm?.type === VAR) throw new PrologError('instantiation_error');
   const preflight = preflightOptionList(optionTerm, env);
   if (goal.arity === 3) streamReference(goal.args[0], env);
@@ -1712,9 +1716,9 @@ function* writeTermBuiltin({ solver, goal, env }) {
   const optionTerm = goal.args[goal.arity - 1];
   const streamTerm = goal.arity === 3 ? deref(goal.args[0], env) : null;
 
-  // ISO 8.14.2.3 error order:
-  // a) variable stream; b) partial/options-variable; c) non-list options;
-  // d) bad stream-or-alias; e) invalid write option; then stream errors.
+  // EyeProlog's selected 8.14.2.3 overlap order. Each listed error condition
+  // is covered independently; 7.12 makes simultaneous-error selection
+  // implementation dependent unless another procedural requirement constrains it.
   if (streamTerm?.type === VAR) throw new PrologError('instantiation_error');
   const preflight = preflightOptionList(optionTerm, env);
   const optionItems = requireProperOptionList(preflight);
@@ -2187,7 +2191,9 @@ function flatFindallTemplate(template) {
 
 function* findallBuiltin({ solver, goal, env }) {
   const [template, innerGoal, bag] = goal.args;
-  // ISO 8.10.1.3 diagnoses Goal before Instances when both are erroneous.
+  // EyeProlog validates Goal before Instances when both are erroneous. ISO 7.12
+  // makes simultaneous-error selection implementation dependent; this order is
+  // a documented/tested processor choice, not a blanket table-order rule.
   const invoked = callable(innerGoal, env);
   assertListOrPartial(bag, env);
   const collector = solver.cloneForInnerGoal(10000000);
@@ -2252,7 +2258,9 @@ function sortedUnique(items) {
 
 function allSolutionsBuiltin(asSet) {
   return function* ({ solver, goal, env }) {
-    // ISO 8.10.2.3/8.10.3.3 diagnose the iterated goal before Instances.
+    // EyeProlog validates the iterated goal before Instances. ISO 7.12 makes
+    // simultaneous-error selection implementation dependent; keep this stable as
+    // a processor choice rather than describing it as mandatory table ordering.
     const { iterated, quantified } = bagGoalParts(goal.args[1], env);
     assertListOrPartial(goal.args[2], env);
     const free = freeVariables(iterated, goal.args[0], quantified, env);

package/src/program.js

@@ -12,7 +12,7 @@ import {
   parseGoalText,
   tryParseClausesFastInto,
 } from './parser.js';
-import { PrologError, getStrictIsoRegistry } from './iso.js';
+import { PrologError, convertClauseBodyTerm, getStrictIsoRegistry } from './iso.js';
 import { currentWorkingDirectory, fs, path } from './platform.js';
 import {
   standardLibrarySources,
@@ -627,6 +627,14 @@ class ProgramBuilder {
       }
 
       if (!isDirectiveClause(clause)) {
+        if (program.strictIso && Array.isArray(clause.body) && clause.body.length > 0) {
+          // ISO 7.6.2 applies when source text is prepared as well as when a
+          // clause term is asserted dynamically. Keep the original variable
+          // objects while wrapping variable goals in call/1 so sharing with
+          // the head (and recursively through ;/2 and ->/2) is preserved for
+          // later clause/2 and retract/1 conversion back to terms.
+          clause.body = clause.body.map((goal) => convertClauseBodyTerm(goal));
+        }
         assertHeadIsDefinable(clause.head, program.strictIso);
         const head = clause.head;
         if (head.type !== ATOM && head.type !== COMPOUND) continue;

package/test/conformance/ISO-BUILTIN-MODE-ERROR-MATRIX.md

@@ -4,12 +4,21 @@ This matrix turns the broad built-in audit in `ISO-COMPLIANCE.md` into smaller,
 release-gated units. The normative baseline is ISO/IEC 13211-1:1995 plus
 Technical Corrigenda 1:2007, 2:2012, and 3:2017.
 
-A `covered` row has an executable assertion for the prescribed successful mode,
-failure behavior, or error condition. `not applicable` records a conditional
-standard branch that cannot occur under EyeProlog's documented processor
-choices. The table is intentionally explicit about what has and has not been
-closed: this tranche row-audits 8.2-8.5 and 8.15-8.17; 8.6-8.14 remain under
-the broader audit and will be expanded in later passes.
+A `covered` row has executable evidence for the required successful mode,
+failure behavior, or individual error condition. `not applicable` records a
+conditional standard branch that cannot occur under EyeProlog's documented
+processor choices. ISO 7.12 makes the reported error implementation dependent
+when more than one error condition is simultaneously satisfied. Accordingly,
+this matrix treats overlap tests as stable EyeProlog processor choices unless a
+more specific procedural requirement or Corrigendum constrains the result; it
+does not infer a universal priority merely from the textual order of an error
+table.
+
+The table is intentionally explicit about what has and has not been closed.
+The current audit now covers the complete 8.2-8.17 built-in family at the
+level of prescribed modes, success/failure behavior, individual error
+conditions, and explicit not-applicable processor branches. Higher-level
+Clause 7 and Clause 9 semantics remain tracked separately.
 
 The focused assertions added for this matrix live in `test/run-iso-strict.mjs`;
 existing file-based cases remain additional independent evidence.
@@ -102,6 +111,171 @@ The Corrigendum 2 additions have the same shape.
 | Cor.2 8.5.5 `term_variables/2` | supplied partial/list result | covered | Corrigendum cases |
 | Cor.2 8.5.5 error (a) | second argument neither partial list nor list -> list type error | covered | strict `term_variables(t,[X|foo])` |
 
+## 8.6 — arithmetic evaluation
+
+| Clause / predicate | Prescribed row | Status | Executable evidence |
+| --- | --- | --- | --- |
+| 8.6.1 `is/2` | evaluate the second argument and unify/check the result | covered | strict `X is 1+2, X=3`, arithmetic corpus |
+| 8.6.1 failed result unification | a successfully evaluated value need not unify with the first argument | covered | strict `4 is 1+2` fails |
+| 8.6.1 error (a) | variable expression -> instantiation error | covered | strict `X is Y` |
+| 8.6.1 delegated expression errors | evaluation may report any applicable 7.9.2 error | covered | strict `X is foo` plus Clause 9 arithmetic/error suites |
+
+## 8.7 — arithmetic comparison
+
+| Clause / predicate | Prescribed row | Status | Executable evidence |
+| --- | --- | --- | --- |
+| 8.7.1 `(=:=)/2` | evaluate two expressions and test arithmetic equality | covered | strict `1 =:= 1`, arithmetic comparison corpus |
+| 8.7.1 `(=\=)/2` | evaluate two expressions and test arithmetic inequality | covered | strict `1 =\= 2` |
+| 8.7.1 `(<)/2` | arithmetic less-than | covered | strict `1 < 2` |
+| 8.7.1 `(=<)/2` | arithmetic less-than-or-equal | covered | strict `1 =< 1` |
+| 8.7.1 `(>)/2` | arithmetic greater-than | covered | strict `2 > 1` |
+| 8.7.1 `(>=)/2` | arithmetic greater-than-or-equal | covered | strict `2 >= 2` |
+| 8.7.1 error (a) | first expression variable -> instantiation error | covered | strict variable-first assertions across the comparison family |
+| 8.7.1 error (b) | second expression variable -> instantiation error | covered | strict variable-second assertions across the comparison family |
+| 8.7.1 delegated expression errors | either expression may report an applicable 7.9.2 error | covered | strict `foo =:= 1` plus Clause 9 error suites |
+| 8.7 mixed integer/float operation | selected Part 1 I-to-F comparison operations, including conversion overflow | covered | dedicated strict mixed-comparison tests |
+
+## 8.8 — clause inspection
+
+| Clause / predicate | Prescribed row | Status | Executable evidence |
+| --- | --- | --- | --- |
+| 8.8.1 `clause/2` | enumerate clauses of a public user-defined procedure | covered | dynamic-clause tests and grouped-solutions/clause corpus |
+| 8.8.1 error (a) | variable head -> instantiation error | covered | strict `clause(X,_)` |
+| 8.8.1 error (b) | non-callable head -> callable type error | covered | strict `clause(4,_)` |
+| 8.8.1 error (c) | private procedure -> access/private-procedure permission error | covered | strict static/private tests |
+| 8.8.1 error (d) | fixed non-callable Body -> callable type error | covered | strict dynamic `clause(p(_),4)` coverage |
+| 8.8.1 clause-to-term conversion | source variable goals become `call/1` while preserving sharing with the head | covered | strict `foo(X):-X` -> `clause(foo(C),call(C))`; nested `;/2` and `->/2` regressions |
+| 8.8.2 `current_predicate/1` | enumerate/query user-defined predicate indicators, including empty declared procedures | covered | strict row audit and empty-procedure lifetime tests |
+| 8.8.2 error (a) | fixed non-predicate-indicator -> predicate-indicator type error | covered | strict `current_predicate(4)` |
+
+## 8.9 — database modification
+
+| Clause / predicate | Prescribed row | Status | Executable evidence |
+| --- | --- | --- | --- |
+| 8.9.1 `asserta/1` | convert term to clause and insert before existing clauses | covered | dynamic-database corpus and strict body-conversion tests |
+| 8.9.1 errors (a-b) | variable/non-callable Head -> instantiation/callable type error | covered | strict `asserta(_)`, `asserta(4)` |
+| 8.9.1 error (c) | Body cannot be converted to a goal -> callable type error | covered | strict `asserta((p:-4))` and nested-control conversion tests |
+| 8.9.1 error (d) | static procedure -> modify/static-procedure permission error | covered | strict static-procedure tests |
+| 8.9.2 `assertz/1` | convert term to clause and insert after existing clauses | covered | dynamic-database corpus and strict body-conversion tests |
+| 8.9.2 errors (a-d) | same Head/Body/static families as `asserta/1` | covered | strict `assertz(_)`, `assertz(4)`, `assertz((p:-4))`, static-procedure tests |
+| 8.9.3 `retract/1` | retract matching dynamic clauses re-executably using the logical update view | covered | dynamic-database and logical-update-view suites |
+| 8.9.3 errors (a-b) | variable/non-callable Head -> instantiation/callable type error | covered | strict `retract(_)`, `retract(4)` |
+| Cor.2 8.9.3 error (c) | static procedure -> **modify**/static-procedure permission error | covered | strict `retract(atom(_))` and Corrigendum coverage |
+| 8.9.3 clause-term matching | converted source body retains head/body variable identity when matched by `retract/1` | covered | strict `retract((foo(C):-call(C)))` regression |
+| 8.9.4 `abolish/1` | remove a dynamic procedure | covered | strict lifetime tests |
+| 8.9.4 errors (a-b) | variable indicator or variable Name/Arity component -> instantiation error | covered | strict `abolish(X)`, `abolish(foo/X)` |
+| 8.9.4 error (c) | non-predicate-indicator -> predicate-indicator type error | covered | strict `abolish(foo)` |
+| 8.9.4 error (d) | non-integer Arity -> integer type error | covered | strict `abolish(foo/a)` |
+| 8.9.4 error (e) | non-atom Name -> atom type error | covered | strict `abolish(4/1)` |
+| 8.9.4 error (f) | negative Arity -> non-negative domain error | covered | strict `abolish(foo/(-1))` |
+| 8.9.4 finite-`max_arity` error (g) | Arity exceeds finite `max_arity` | not applicable | selected `max_arity=unbounded` |
+| 8.9.4 error (h) | static procedure -> modify/static-procedure permission error | covered | strict `abolish(atom/1)` |
+| Cor.2 8.9.5 `retractall/1` | remove all matching dynamic heads while retaining the procedure | covered | strict empty-procedure lifetime test and Corrigendum cases |
+| Cor.2 8.9.5 errors (a-c) | variable/non-callable Head or static procedure | covered | strict `retractall(_)`, `retractall(4)`, static-procedure test |
+
+## 8.10 — all solutions
+
+| Clause / predicate | Prescribed row | Status | Executable evidence |
+| --- | --- | --- | --- |
+| 8.10.1 `findall/3` | collect renamed template instances in solution order; empty result succeeds with `[]` | covered | strict `[1,2]` assertion plus all-solutions corpus |
+| 8.10.1 error (a) | variable Goal -> instantiation error | covered | strict `findall(X,Y,L)` |
+| 8.10.1 error (b) | non-callable Goal -> callable type error | covered | strict `findall(X,4,L)` |
+| 8.10.1 error (c) | Instances neither partial list nor list -> list type error | covered | strict `findall(X,true,foo)` |
+| 8.10.2 `bagof/3` | non-empty grouped solution lists, re-executable over free-variable witnesses | covered | grouped-solutions corpus and strict `[1,2]` assertion |
+| 8.10.2 empty solution set | goal fails rather than returning `[]` | covered | strict `bagof(X,fail,L)` |
+| 8.10.2 errors (a-b) | variable/non-callable iterated-goal term -> instantiation/callable type error | covered | strict `bagof(X,Y,L)`, `bagof(X,4,L)` |
+| 8.10.2 error (c) | Instances neither partial list nor list -> list type error | covered | strict `bagof(X,true,foo)` |
+| 8.10.3 `setof/3` | grouped solutions sorted with duplicates removed | covered | strict duplicate/sort assertion plus grouped-solutions corpus |
+| 8.10.3 empty solution set | goal fails rather than returning `[]` | covered | strict `setof(X,fail,L)` |
+| 8.10.3 errors (a-b) | variable/non-callable iterated-goal term -> instantiation/callable type error | covered | strict `setof(X,Y,L)`, `setof(X,4,L)` |
+| 8.10.3 error (c) | Instances neither partial list nor list -> list type error | covered | strict `setof(X,true,foo)` |
+| 8.10.2-3 witness-group order where the standard leaves a choice | implementation dependent | covered | existing grouping tests document EyeProlog's stable selection without turning it into a cross-processor requirement |
+
+
+## 8.11 — stream selection and control
+
+| Clause / predicate | Prescribed row | Status | Executable evidence |
+| --- | --- | --- | --- |
+| 8.11.1 `current_input/1` | unify/query the current input stream-term | covered | strict current-input success assertion |
+| 8.11.1 error | fixed argument is neither variable nor stream-term -> stream domain error | covered | strict `current_input(foo)` |
+| 8.11.2 `current_output/1` | unify/query the current output stream-term | covered | strict current-output success assertion |
+| 8.11.2 error | fixed argument is neither variable nor stream-term -> stream domain error | covered | strict `current_output(foo)` |
+| 8.11.3 `set_input/1` | select an open input stream by stream-term or alias | covered | stream-selection corpus |
+| 8.11.3 errors | variable; invalid stream-or-alias; missing stream; output stream | covered | dedicated strict assertions for all four conditions |
+| 8.11.4 `set_output/1` | select an open output stream by stream-term or alias | covered | stream-selection corpus |
+| 8.11.4 errors | variable; invalid stream-or-alias; missing stream; input stream | covered | dedicated strict assertions for all four conditions |
+| 8.11.5 `open/4`, `open/3` | open a source/sink with standardized mode/options and return a fresh stream | covered | stream corpus plus strict successful/error probes |
+| 8.11.5 errors: instantiation | variable source/mode or variable option element | covered | strict `open/4` assertions |
+| 8.11.5 errors: argument shapes | non-atom mode; non-list options; non-variable stream output (Cor.2 uninstantiation) | covered | strict `open/4` assertions |
+| 8.11.5 errors: domains | invalid source/sink, I/O mode, or stream option | covered | strict `open/4` assertions |
+| 8.11.5 source/sink errors | missing read source or source/sink that cannot be opened | covered | strict host-I/O probes for existence/permission conditions |
+| 8.11.5 alias collision | `alias(A)` already names an open stream -> open permission error with complete `alias(A)` culprit | covered | focused issue #65 alias-collision regression |
+| 8.11.5 `reposition(true)` impossible | permission error when the requested stream cannot be repositioned | covered | stream option corpus and implementation-defined stream capability checks |
+| 8.11.6 `close/2`, `close/1` | close an open non-standard stream and maintain current-stream fallbacks | covered | stream lifecycle corpus |
+| 8.11.6 errors | variable stream/option element; non-list options; invalid stream-or-alias; invalid close option; missing stream | covered | strict close assertions |
+| 8.11.6 `force(true)` | presence of `force(true)` suppresses resource/system close failure regardless of contradictory later `force(false)` | covered | dedicated two-order strict regression |
+| 8.11.7 `flush_output/1`, `flush_output/0` | flush an output stream/current output | covered | strict success assertion and stream corpus |
+| 8.11.7 errors | variable; invalid stream-or-alias; missing stream; input stream | covered | dedicated strict assertions |
+| 8.11.8 `stream_property/2` | enumerate properties of currently open streams; order is implementation dependent | covered | stream-property corpus and strict checks |
+| 8.11.8 stream-term error | fixed non-stream-term -> stream domain error | covered | strict `stream_property(foo,_)` |
+| 8.11.8 property error | fixed non-stream-property -> stream-property domain error | covered | strict invalid-property assertion |
+| 8.11.8 closed valid stream-term | no pair exists for a stream that is no longer open -> fail | covered | dedicated closed-stream regression |
+| 8.11.8 `at_end_of_stream/0-1` | test current/named stream end or past-end state | covered | strict success and EOF corpus |
+| 8.11.8 `at_end_of_stream/1` errors | variable; invalid stream-or-alias; missing stream | covered | dedicated strict assertions |
+| 8.11.9 `set_stream_position/2` | set a repositionable open stream to a valid stream position | covered | dedicated positioned-stream success assertion |
+| 8.11.9 errors | variable stream/position; invalid stream-or-alias/position; missing stream; non-repositionable stream | covered | dedicated strict assertions |
+
+## 8.12 — character input/output
+
+| Clause / predicate | Prescribed row | Status | Executable evidence |
+| --- | --- | --- | --- |
+| 8.12.1 `get_char/1-2` | input next text character or EOF indicator | covered | stream/character corpus and strict probes |
+| 8.12.1 `get_code/1-2` | input next text character code or `-1` at EOF | covered | stream/code corpus and strict probes |
+| 8.12.1 argument errors | variable stream; invalid fixed in-character; non-integer fixed code | covered | dedicated strict assertions |
+| 8.12.1 stream errors | invalid stream-or-alias; missing stream; output stream; binary stream; past-end with `eof_action(error)` | covered | dedicated strict and constructed-stream assertions |
+| 8.12.1 input entity/code representation | non-character input entity or fixed integer not an in-character code | covered | strict entity/code representation regressions; bad-code check is deferred until earlier stream/entity conditions are resolved |
+| 8.12.2 `peek_char/1-2`, `peek_code/1-2` | inspect next character/code without changing stream position | covered | strict probes and stream corpus |
+| 8.12.2 errors | corresponding 8.12.1 argument, stream, EOF, entity and code-representation conditions | covered | dedicated strict assertions including overlap regression |
+| 8.12.3 `put_char/1-2` | output one text character | covered | output corpus |
+| 8.12.3 `put_code/1-2` | output character selected by character code | covered | output corpus |
+| 8.12.3 `nl/0-1` | output implementation-defined new-line character | covered | output corpus |
+| 8.12.3 argument errors | variable character/code or wrong character/integer type | covered | dedicated strict assertions |
+| 8.12.3 stream errors | variable/invalid/missing stream; input stream; binary stream | covered | dedicated strict and constructed-stream assertions |
+| 8.12.3 character-code representation | integer outside processor character-code set | covered | strict `put_code/1` boundary assertion |
+
+## 8.13 — byte input/output
+
+| Clause / predicate | Prescribed row | Status | Executable evidence |
+| --- | --- | --- | --- |
+| 8.13.1 `get_byte/1-2` | input next byte or `-1` at EOF | covered | strict binary-stream success and byte corpus |
+| 8.13.1 errors | variable stream; invalid fixed in-byte; invalid/missing/output stream; text stream; EOF-action conditions | covered | strict assertions and EOF stream corpus |
+| 8.13.2 `peek_byte/1-2` | inspect next byte without changing position | covered | strict binary-stream success and byte corpus |
+| 8.13.2 errors | corresponding fixed-byte, stream, text-stream, and EOF conditions | covered | strict assertions / shared byte-I/O implementation tests |
+| 8.13.3 `put_byte/1-2` | output one byte to a binary stream | covered | strict binary-output success and byte corpus |
+| 8.13.3 errors | variable byte/stream; non-byte value; invalid/missing/input stream; text stream | covered | dedicated strict assertions |
+
+## 8.14 — term input/output, operators, and character conversion
+
+| Clause / predicate | Prescribed row | Status | Executable evidence |
+| --- | --- | --- | --- |
+| 8.14.1 `read_term/3`, `read_term/2`, `read/1-2` | read a term using the standardized read-option surface | covered | term-I/O corpus, Corrigendum 3 cases, strict success/error suite |
+| 8.14.1 option/argument errors | stream/option instantiation, non-list options, invalid read option | covered | strict 8.14.1 individual-condition assertions |
+| 8.14.1 stream/input errors | invalid/missing/output/binary stream, past-end state, invalid input character, syntax error | covered | strict and constructed-stream assertions; post-N289 STC #76 is pinned by invalid-character read regressions |
+| 8.14.1 conditional finite-number/arity representation branches | limits tied to finite selected processor bounds | not applicable where bound is unbounded | EyeProlog selects unbounded integers/`max_arity`; the implementation-defined finite binary64 input limits are pinned separately, including post-N289 STC #73 `max_float` / `min_float` coverage |
+| 8.14.1 Corrigendum options | `variables/1`, `variable_names/1`, `singletons/1` list traversal/unification behavior | covered | Corrigendum 3 metadata tests and STC #48 regression |
+| 8.14.2 `write_term/3`, `write_term/2`, `write/1-2`, `writeq/1-2` | write terms under standardized write options | covered | term-I/O/write-back corpus and strict writer suite |
+| 8.14.2 option/argument errors | stream/option instantiation, non-list options, invalid write option | covered | strict 8.14.2 assertions |
+| 8.14.2 stream/output errors | invalid/missing/input/binary stream and character representation conditions | covered | strict and constructed-stream assertions |
+| 8.14.2 contradictory write options | rightmost option applies | covered | writer option corpus |
+| 8.14.3 `op/3` | add/remove operators subject to Part 1 restrictions | covered | operator corpus and preparation-time ordering tests |
+| 8.14.3 errors | priority/specifier/name instantiation/type/domain plus protected-operator permission conditions | covered | strict `op/3` individual-condition suite |
+| 8.14.4 `current_op/3` | enumerate/query current operator definitions | covered | operator corpus and strict success assertion |
+| 8.14.4 errors | invalid priority/specifier/operator filters | covered | strict `current_op/3` individual-condition suite |
+| 8.14.5 `char_conversion/2` | update character-conversion mapping | covered | preparation/runtime conversion tests and strict success assertion |
+| 8.14.5 errors | input/output instantiation and processor-character representation conditions | covered | dedicated strict assertions |
+| 8.14.6 `current_char_conversion/2` | enumerate/query current conversion mapping | covered | strict success assertion and conversion corpus |
+| 8.14.6 errors | fixed input/output is not a character | covered | dedicated strict assertions |
+
 ## 8.15 — logic and control
 
 | Clause / predicate | Prescribed row | Status | Executable evidence |
@@ -190,16 +364,15 @@ built-in matrix does not have a gap at 8.17.
 | 8.17.4 variable status | instantiation error | covered | strict `halt(X)` |
 | 8.17.4 non-integer status | integer type error | covered | strict `halt(a)` |
 
-## Remaining row-audit work
-
-This file deliberately does not relabel the whole 8.2-8.17 family as complete.
-The next row-by-row passes are:
+## Remaining audit work
 
-- 8.6-8.7 arithmetic predicates and expression-evaluation interactions;
-- 8.8-8.10 database and all-solutions predicates, including all conditional
-  static/private/dynamic branches;
-- 8.11-8.14 streams, character/byte I/O, options, and term I/O, including the
-  remaining option/mode cross-product.
+The built-in **8.2-8.17 row audit is complete** at the level tracked by this
+file: prescribed modes, success/failure behavior, individual error conditions,
+and conditional/not-applicable processor branches all have explicit outcomes.
+ISO 7.12 simultaneous-error selection remains an implementation-dependent
+processor choice unless more specific normative text constrains it.
 
-Clause 9 exceptional-value rows and Clause 6/7 processor semantics remain
-tracked separately in `ISO-COMPLIANCE.md` and `ISO-PROCESSOR-REQUIREMENTS.md`.
+The remaining #65 work is therefore above/below this built-in table: Clause 6
+text/rejection mapping, Clause 7 processor/control semantics, Clause 9
+exceptional-value rows, residual Clause 5 dependency rows, and the external
+conversion/variable-name conformance corpora.