eyeprolog 1.3.56 → 1.3.57

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.3.56",
+  "version": "1.3.57",
   "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 |
+| 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`; finite binary64 input limits remain documented separately |
+| 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.

package/test/conformance/ISO-COMPLIANCE.md

@@ -15,7 +15,7 @@ marked `covered` means EyeProlog has implementation and executable tests for
 that family and no known open defect in the listed behavior. A row marked
 `audit` means the family is implemented and tested, but the project has not yet
 mapped every normative `shall`, option combination, prescribed error, and
-error-ordering alternative to an individual executable assertion.
+relevant implementation-dependent overlap choice to an explicit audit outcome.
 
 ## Processor compliance requirements
 
@@ -36,14 +36,14 @@ error-ordering alternative to an individual executable assertion.
 | Clause 6 — tokens, terms, lists, operators, quoted text | audit | Complete vendored WG17 syntax matrix, `lexical_and_curly_terms`, `scryer_lexical_terms`, operator suites, syntax-error cases, quoted-layout/escape error cases, writer/read-back regressions, and Unicode-scalar PCS/collation boundary tests. The implementation-defined 6.5/6.6 character-model decisions are now closed; wider shall-by-shall lexical mapping remains open. |
 | 7.1-7.3 — term types, term order, unification | audit | Standard-order, identity, finite-tree and occurs-check suites, Corrigendum 2 term predicates, plus strict checks for the required `variable < float < integer < atom < compound` type order, PCS-based atom collation, and the `max_arity=unbounded` compound-term model. The normal JavaScript API string term is now explicitly documented as a 5.5.4 extension and rejected at strict program/goal entry so it cannot add a sixth strict-core type. |
 | 7.4 — Prolog text and directives | audit | All Part 1 directive indicators are parsed; include/ensure-loaded/operator/flag/character-conversion behavior has executable coverage. Preparation-time `char_conversion/2` affects later unquoted source text and respects `char_conversion=off`. Strict preparation now enforces declaration-before-clause ordering for `dynamic/1`, `multifile/1`, and `discontiguous/1`, cross-text `multifile/1`, discontiguous clause grouping, empty declared procedures, include textual-replacement behavior, and one-time initialization per prepared program. The remaining shall-by-shall mapping is still open. |
-| 7.5-7.6 — database and term/clause conversion | audit | Dynamic database and logical-update-view suites. Strict mode restores Part 1 private-static/public-dynamic `clause/2` access; focused strict checks cover the database built-ins and empty-procedure lifetime. Runtime assertion conversion now applies 7.6.2 recursively through conjunction, disjunction, and if-then: nested variables become `call/1`, and an invalid nested branch is rejected while `asserta/1` or `assertz/1` converts the term instead of being stored for a later execution-time failure. Runtime protection includes the solver-native conjunction control construct `','/2` and, following STC #56's accepted-direction action item, `(:-)/1-2` for database modification/private access while leaving their call behavior distinct. The remaining clause-conversion shall-by-shall mapping is still open. |
+| 7.5-7.6 — database and term/clause conversion | audit | Dynamic database and logical-update-view suites. Strict mode restores Part 1 private-static/public-dynamic `clause/2` access; focused strict checks cover the database built-ins and empty-procedure lifetime. Clause-body conversion now applies 7.6.2 both to prepared source clauses and runtime `asserta/1` / `assertz/1`: variables become `call/1`, `,/2`, `;/2`, and `->/2` are converted recursively, and head/body variable identity is preserved so `clause/2` and `retract/1` observe the converted term correctly. Runtime protection includes the solver-native conjunction control construct `','/2` and, following STC #56's accepted-direction action item, `(:-)/1-2` for database modification/private access while leaving their call behavior distinct. The remaining clause-conversion shall-by-shall mapping is still open. |
 | 7.7 — execution and backtracking | audit | Control/search suites. Strict mode disables EyeProlog automatic tabling, cycle guards, and recursive numeric shortcuts so core execution uses ordinary clause selection/backtracking. |
 | 7.8 — control constructs and exceptions | audit | call, cut, conjunction, disjunction (including failed branches after callee-local cuts), if-then, catch/throw, renamed-copy tests. The 8.15 built-in slice (`\+/1`, `once/1`, `repeat/0`, Corrigendum 2 `call/2..8`, `false/0`) is now row-audited in [ISO-BUILTIN-MODE-ERROR-MATRIX.md](ISO-BUILTIN-MODE-ERROR-MATRIX.md); the remaining general control-construct semantics ledger stays open. |
 | 7.9 — expression evaluation | audit | Arithmetic/evaluation/error suites, including Corrigenda. Strict mode now pins direct-variable precedence, 7.9.2 non-evaluable `F/N` errors (including STC #69), arithmetic numeric/integer type errors, float-only rounding conversions, the Part 1 mixed integer/float comparison conversion rule, I->F overflow before floating evaluable functors (STC #42), explicit `exp/1`/power underflow, and prescribed negative/zero power errors before later conversion overflow. Unbounded integer powers/shifts no longer leak host `RangeError`; finite-host exhaustion is normalized to `resource_error(memory)` in line with the Part 1 resource-error note and STC #21. The remaining exceptional-value/error-precedence rows are still being exhaustively enumerated. |
-| 7.10 — input/output concepts | audit | Stream, character/byte I/O, read/write options, operator-sensitive write-back, and Corrigendum 3 writer cases. The audit now also covers write-mode creation/truncation, append creation, repositioned overwrite, flushing, EOF actions, close/current-stream handling, strict stream-position terms, stream-property validation, stream-term requirements, text-vs-binary permission errors, and the prescribed `alias(A)` culprit for `open/4` alias collisions. The latest 8.11/8.12 pass also makes `close/2`'s `force(true)` semantics presence-based and defers `get_code/1-2` / `peek_code/1-2` invalid in-character-code representation errors until after the earlier stream existence/mode/type/EOF/entity conditions. The full option/mode cross-product is still being mapped. |
+| 7.10 — input/output concepts | audit | Stream, character/byte I/O, read/write options, operator-sensitive write-back, and Corrigendum 3 writer cases. The complete 8.11-8.14 built-in mode/error family is now row-audited in [ISO-BUILTIN-MODE-ERROR-MATRIX.md](ISO-BUILTIN-MODE-ERROR-MATRIX.md), including lifecycle/current-stream handling, stream positions, text/binary permissions, EOF actions, `force(true)`, input-code representation timing, term-I/O options, operators, and character conversion. `stream_property/2` now also distinguishes a malformed stream-term (domain error) from a valid stream-term whose stream is no longer open (ordinary failure). The higher-level 7.10 source/sink, buffering, positioning, and implementation-defined stream semantics remain under shall-by-shall audit. |
 | 7.11 — flags | covered | The complete Part 1 flag set, selected defaults, standard value domains, changeability, `current_prolog_flag/2`, and `set_prolog_flag/2` error behavior have dedicated strict tests. EyeProlog selects `bounded=false` and `integer_rounding_function=toward_zero`; valid alternative values of those fixed flags reach `permission_error(modify,flag,...)`, while `max_integer` and `min_integer` have no current value. STC #70 is recorded explicitly: EyeProlog has no separate finite procedure-arity ceiling, so the optional `max_procedure_arity` flag is absent while `max_arity` remains `unbounded`. Strict mode excludes the EyeProlog `occurs_check` extension. |
-| 7.12 — errors | audit | ISO `error(Error, Context)` envelope, type/domain/permission/representation/evaluation/syntax/resource families and focused error cases. [ISO-BUILTIN-MODE-ERROR-MATRIX.md](ISO-BUILTIN-MODE-ERROR-MATRIX.md) now gives explicit prescribed mode/error rows for 8.2-8.5 and 8.15-8.17, including Corrigendum additions and selected not-applicable finite-`max_arity` branches. Exact ISO 8.14.1-8.14.4 precedence and the recent 8.11/8.12 overlaps are also covered. The one-row map remains open for 8.6-8.14 and for the remaining Clause 7/9 exceptional-order interactions. |
-| 8.2-8.17 — built-in predicates | audit | Predicate-family coverage is mapped in ISO-MATRIX.md. The new [ISO-BUILTIN-MODE-ERROR-MATRIX.md](ISO-BUILTIN-MODE-ERROR-MATRIX.md) closes 8.2-8.5 and 8.15-8.17 at one row per prescribed mode/error condition (with finite-`max_arity` branches explicitly marked not applicable under EyeProlog's `unbounded` choice). The still-open row audit is therefore narrowed to 8.6-8.14, especially database/all-solutions and the remaining stream/term-I/O option cross-product. |
+| 7.12 — errors | audit | ISO `error(Error, Context)` envelope, type/domain/permission/representation/evaluation/syntax/resource families and focused error cases. [ISO-BUILTIN-MODE-ERROR-MATRIX.md](ISO-BUILTIN-MODE-ERROR-MATRIX.md) now gives explicit mode/error-condition outcomes across the complete 8.2-8.17 built-in family, including Corrigendum additions and not-applicable conditional branches. The audit records the 7.12 rule that simultaneous error conditions are implementation dependent: overlap regressions document stable EyeProlog choices rather than inventing a universal table-order requirement. Remaining work is concentrated in non-built-in Clause 7 semantics, Clause 9 exceptional interactions, and processor-level error conditions. |
+| 8.2-8.17 — built-in predicates | covered | [ISO-BUILTIN-MODE-ERROR-MATRIX.md](ISO-BUILTIN-MODE-ERROR-MATRIX.md) now records the complete Part 1 + Corrigenda built-in family at one row per prescribed mode, success/failure behavior, individual error condition, and conditional/not-applicable branch. The row audit exposed and fixed source/runtime 7.6.2 body conversion/variable sharing, strict host-string leakage, input-code error timing, `close/2` force handling, and closed-stream `stream_property/2` behavior. Simultaneous-error choices are documented as implementation dependent under 7.12 unless separately constrained. |
 | Clause 9 — evaluable functors | audit | Integer/float/rounding/transcendental/bitwise suites and corrigendum cases. Strict mode excludes the EyeProlog-only evaluable atom `e`, retains Corrigendum 2 arithmetic additions, reports unknown zero-arity evaluables with the required `F/0` culprit shape, distinguishes non-evaluable `F/N` errors from numeric/integer operand errors per 7.9.2 and STC #69, and enforces float-only rounding modes, performs I->F conversion before floating functors (including overflow), reports the explicit `exp/1`, `**/2`, and Corrigendum 2 `^/2` underflow conditions, preserves the power-specific undefined conditions ahead of conversion overflow, and uses the Part 1 integer-to-float rule for mixed arithmetic comparisons. Normal mode retains EyeProlog's exact mixed-type comparison and round-to-zero arithmetic behavior as extensions. Unbounded BigInt resource exhaustion is translated into the Prolog error model rather than leaking host exceptions. Host floating-point representation choices remain documented implementation-defined behavior; the remaining exceptional-value rows are still under audit. |
 | Corrigendum 1 | covered | Double-quoted atom/operator-priority corrections have dedicated cases. |
 | Corrigendum 2 | covered | Added predicates/functors, catch corrections, bar/operator and uninstantiation corrections have dedicated cases. |
@@ -82,7 +82,7 @@ removes the artificial 65535 checks from source parsing, `functor/3`, `=../2`,
 predicate indicators, and Corrigendum 2 `call/N` closure expansion. Practical
 host exhaustion remains a resource condition rather than a declared term-arity
 boundary. Focused strict tests also lock the corrected 8.5 term-construction
-errors, 8.8 clause-access precedence, 8.10 all-solutions goal/list precedence,
+errors, selected 8.8 clause-access and 8.10 all-solutions overlap behavior,
 database update errors, and Corrigendum 3 variable metadata traversal/write
 naming.
 
@@ -97,8 +97,9 @@ standard value that is valid but not selectable from a value outside the
 standard domain: attempts to change fixed `bounded` or
 `integer_rounding_function` to another standard value therefore reach the
 required permission error. `read_term/3`, `write_term/3`, `op/3`, and
-`current_op/3` now follow their prescribed error precedence, including cases
-where more than one argument is erroneous. Strict `write_term/2-3` accepts only
+`current_op/3` now cover their required error conditions individually and keep
+EyeProlog's chosen simultaneous-error behavior stable. Section 7.12 makes that
+choice implementation dependent when several error conditions hold at once. Strict `write_term/2-3` accepts only
 the Part 1 plus Corrigendum 3 option surface; the normal-profile
 `double_quotes/1` write option remains an explicitly documented EyeProlog
 extension.
@@ -115,7 +116,7 @@ EOF, close, and current-stream behavior. Corrigendum 2 `keysort/2` variable and
 non-pair errors are corrected. Strict arithmetic no longer exposes the
 EyeProlog-only evaluable atom `e`, while the Corrigendum arithmetic additions
 remain available. These corrections narrow the remaining `audit` rows but do
-not by themselves close the full shall-by-shall/error-order exit criteria.
+not by themselves close the full shall-by-shall/error-condition exit criteria.
 
 The next Corrigendum 2 pass closed the prescribed `call/2..8` max-arity
 branch for processors with a finite `max_arity`, and corrected reverse
@@ -128,8 +129,10 @@ expansion itself remains covered by strict regressions.
 
 The following Part 1 pass tightens more of the still-open prescribed-error and
 arithmetic matrix. `arg/3`, `atom_concat/3`, `sub_atom/5`, `number_chars/2`,
-`number_codes/2`, and `char_conversion/2` now follow the standard ordering when
-multiple error conditions are simultaneously present. Corrigendum 2 partial
+`number_codes/2`, and `char_conversion/2` now cover their individual standard
+error conditions and retain deterministic EyeProlog choices for overlapping
+conditions; 7.12 explicitly leaves such simultaneous-error selection
+implementation dependent unless another rule constrains it. Corrigendum 2 partial
 versus improper list distinctions are applied consistently to atomic and
 number conversion. Clause 9 strict evaluation now gives the prescribed
 number/integer operand diagnostics, checks direct-variable instantiation first,
@@ -187,6 +190,29 @@ now documented under 5.5.4, while strict `Program` construction and strict
 keeps the host extension available in normal mode without allowing it to become
 a sixth term type in the Part 1 strict execution domain.
 
+A row-level 8.6-8.10 pass then turns arithmetic predicates, clause/database
+operations, and all-solutions predicates into explicit mode/error-condition
+entries. During that audit, strict source preparation exposed a 7.6.2 defect:
+a clause such as `foo(X) :- X.` was executed as a variable goal but was not
+stored in the converted `call(X)` form, so `clause(foo(C),call(C))` and the
+corresponding `retract/1` pattern lost the required head/body variable identity.
+Strict preparation now performs the same recursive body conversion used by
+runtime assertion while preserving the original variable objects. The pass
+also records the 7.12 rule for simultaneous errors, so deterministic overlap
+tests are treated as processor choices unless more specific normative text
+constrains them.
+
+The subsequent 8.11-8.14 pass completes the built-in row audit. Stream
+selection/control, character/code input and output, byte I/O, term I/O,
+operators, and character conversion now each have explicit success/mode and
+individual-error outcomes in `ISO-BUILTIN-MODE-ERROR-MATRIX.md`. During this
+pass `stream_property/2` exposed a lifecycle distinction: a syntactically valid
+stream-term for a stream that has been closed denotes no currently open stream
+property pair and therefore fails, whereas a term that is not a stream-term is
+still a `domain_error(stream, ...)`. This leaves the remaining #65 checklist
+focused on Clause 6/7/9 processor semantics and external corpora rather than
+unmapped built-in tables.
+
 ## Post-Corrigendum STC cross-check
 
 The public WG17 STC draft is tracked as useful defect-discovery material, but it
@@ -261,8 +287,9 @@ ISO/IEC 13211-1 processor” until all of the following are true:
 3. the external WG17 conversion and variable-name conformity corpora have
    joined the now-complete syntax corpus in strict core mode, with every
    difference explained or fixed;
-4. prescribed modes, errors, side effects, and relevant error precedence for
-   every Part 1 built-in have executable coverage;
+4. prescribed modes, individual error conditions, side effects, and any
+   precedence actually constrained by procedural rules or Corrigenda have
+   executable coverage, while 7.12 simultaneous-error choices are documented;
 5. every `audit gap` recorded in the ISO 5.4 decision index is either fixed or
    explicitly excluded from the strict-conformance claim; and
 6. an external conformance run has found no unexplained deviations.

package/test/conformance/ISO-MATRIX.md

@@ -12,9 +12,9 @@ compliance audit and the remaining work before a full conformance claim.
 | Clause 7 term order and unification | finite-tree unification, identity, standard order, errors | `unification_control_information`, `swipl_occurs_check`, `term_modes_and_ordering`, `logtalk_compare_standard_order` |
 | Clause 7 control and exceptions | call, cut, conjunction, disjunction, if-then-else, catch and throw | `cut_control`, `control_and_terms`, `exceptions_and_flags`, `corrigenda_catch_callability`, `throw_copies_ball` |
 | 8.2-8.5 term predicates | unification, Corrigendum 2 tests, comparison, sorting, creation and decomposition | `corrigenda_term_predicates`, `corrigenda_sort_keysort`, `logtalk_arg_unification`, `logtalk_univ`, associated error cases, and the one-row-per-mode/error 8.2-8.5 slice in `ISO-BUILTIN-MODE-ERROR-MATRIX.md`, including conditional finite-`max_arity` branches |
-| 8.6-8.7 arithmetic predicates | `is/2` and all six arithmetic comparisons | `arithmetic`, comparison cases, isolated evaluation errors |
-| 8.8-8.10 database and solutions | logical update view, dynamic mutation, all-solutions grouping | `dynamic_database`, `trealla_logical_update_view`, `corrigenda_retractall`, `grouped_solutions_and_clauses`, plus strict clause/database error and all-solutions precedence checks, recursive 7.6.2 assertion-body conversion through `,/2`, `;/2`, and `->/2`, runtime static/private protection for conjunction, and STC #56 `(:-)/1-2` database protection |
-| 8.11-8.14 streams and term I/O | text/binary streams, properties, units, read/write options and operators | `streams_and_term_io`, `operators`, Corrigendum 3 option cases, stream error cases, strict 8.14.1-8.14.4 option/error-order tests, Corrigendum 3 variable metadata/write naming checks, and issue #65 checks for stream-term/property validation, text-vs-binary permissions, EOF/flush/position, open/close semantics, presence-based `force(true)` close handling, late `get_code/peek_code` in-character-code representation errors, and the exact `alias(A)` collision culprit |
+| 8.6-8.7 arithmetic predicates | `is/2` and all six arithmetic comparisons | `arithmetic`, comparison cases, isolated evaluation errors, and the explicit row-level 8.6-8.7 mode/error-condition audit |
+| 8.8-8.10 database and solutions | logical update view, dynamic mutation, all-solutions grouping | `dynamic_database`, `trealla_logical_update_view`, `corrigenda_retractall`, `grouped_solutions_and_clauses`, the complete row-level 8.8-8.10 mode/error-condition audit, source/runtime 7.6.2 conversion through `,/2`, `;/2`, and `->/2` with preserved head/body variable sharing, selected deterministic overlap checks, runtime static/private protection for conjunction, and STC #56 `(:-)/1-2` database protection |
+| 8.11-8.14 streams and term I/O | text/binary streams, properties, units, read/write options and operators | `streams_and_term_io`, `operators`, Corrigendum 3 option cases, stream error cases, the complete row-level 8.11-8.14 mode/error audit, Corrigendum 3 variable metadata/write naming checks, and issue #65 checks for stream lifecycle/property validation (including closed-stream failure), text-vs-binary permissions, EOF/flush/position, open/close semantics, presence-based `force(true)` close handling, late `get_code/peek_code` in-character-code representation errors, and the exact `alias(A)` collision culprit |
 | 8.15 logic and control | negation, once, repeat, `call/2` through `call/8`, `false/0` | `logtalk_once`, `corrigenda_call_closure`, `false_builtin`, plus the complete 8.15 row-audit in `ISO-BUILTIN-MODE-ERROR-MATRIX.md` |
 | 8.16 atomic processing | atoms, characters, codes and number conversion with prescribed errors | `atomic_term_processing`, focused forward/reverse cases, parenthesized-number rejection, Logtalk-derived cases, and the complete 8.16 mode/error slice in `ISO-BUILTIN-MODE-ERROR-MATRIX.md` |
 | 8.17 flags and halt | complete required Part 1 flag set, selected defaults, standard value domains/changeability, and halt status handling | `exceptions_and_flags`, `remaining_builtins_and_directives`, the complete strict flag audit, halt cases, and explicit 8.17 rows in `ISO-BUILTIN-MODE-ERROR-MATRIX.md` |

package/test/conformance/ISO-PROCESSOR-REQUIREMENTS.md

@@ -17,7 +17,7 @@ certification claim.
 | Requirement | Status | Current evidence / remaining work |
 | --- | --- | --- |
 | 5.1(a) prepare conforming Prolog text | audit | parser/preparation tests, directives, include behavior, preparation-time operators/flags/character conversion, and the complete vendored WG17 syntax matrix; the remaining Clause 6/7.4 shall-by-shall map is still open |
-| 5.1(b) execute conforming Prolog goals | audit | Clause 7-9 suites plus the row-audited built-in slices in `ISO-BUILTIN-MODE-ERROR-MATRIX.md`; 8.6-8.14 and remaining Clause 7/9 semantic rows are still being enumerated |
+| 5.1(b) execute conforming Prolog goals | audit | Clause 7-9 suites plus the now-complete 8.2-8.17 row-audited built-in family in `ISO-BUILTIN-MODE-ERROR-MATRIX.md`; remaining Clause 7/9 processor-semantic rows are still being enumerated |
 | 5.1(c) reject nonconforming text/read terms | audit | syntax-error corpus, WG17 negative syntax cases, strict extension rejection; exhaustive Clause 6 rejection mapping remains open |
 | 5.1(d) specify permitted variations | covered | `ISO-IMPLEMENTATION-DEFINED.md` records the Part 1 implementation-defined choices and implementation-specific extension families |
 | 5.1(e) offer a strictly conforming mode | covered | CLI `--iso-strict` and API `isoStrict: true`; registry/directive/operator/flag extension filtering plus disabled implementation-specific execution shortcuts |
@@ -27,7 +27,7 @@ certification claim.
 | Requirement | Status | Current evidence / remaining work |
 | --- | --- | --- |
 | 5.2 conforming and strictly conforming Prolog text boundary | audit | strict parser accepts Part 1 + Corrigenda syntax plus implementation-defined PCS choices and rejects implementation-specific language facilities; full Clause 6/7.4 dependency audit remains open |
-| 5.3 conforming and strictly conforming Prolog goal boundary | audit | strict registry/control/evaluable filtering and Clause 7-9 regression suites; remaining prescribed mode/error and goal-semantics rows remain open |
+| 5.3 conforming and strictly conforming Prolog goal boundary | audit | strict registry/control/evaluable filtering and Clause 7-9 regression suites; the built-in 8.2-8.17 mode/error rows are closed, while remaining general goal/control and Clause 9 semantic rows stay open |
 | 5.4 accompanying documentation for implementation-defined and implementation-specific features | covered | `ISO-IMPLEMENTATION-DEFINED.md`, *The Art of EyeProlog*, strict-boundary documentation, and release-facing conformance ledgers |
 
 ## 5.5 — extension boundaries
@@ -43,7 +43,7 @@ certification claim.
 | 5.5.6 additional side effects | audit | host/proof/statistics/library effects are outside the strict registry or documented normal-mode behavior; exhaustive side-effect preservation mapping remains part of the Clause 7.7/7.10 audit |
 | 5.5.7 additional control constructs | covered | `tnot/1` and implementation-specific execution optimizations are absent/disabled in strict mode; standard control constructs remain separately audited |
 | 5.5.8 additional flags | covered | normal `occurs_check` extension is absent from strict mode; the Part 1 flag family is fully audited |
-| 5.5.9 additional built-in predicates and error forms | audit | strict registry excludes normal-profile library/native additions; `ISO-BUILTIN-MODE-ERROR-MATRIX.md` now closes 8.2-8.5 and 8.15-8.17 row-by-row, while 8.6-8.14 remain open |
+| 5.5.9 additional built-in predicates and error forms | covered | strict registry excludes normal-profile library/native additions; `ISO-BUILTIN-MODE-ERROR-MATRIX.md` closes the complete 8.2-8.17 family row-by-row; simultaneous-error choices are documented per 7.12 rather than treated as a global table-order mandate |
 | 5.5.10 additional evaluable functors/types | audit | strict mode excludes normal-profile arithmetic extensions such as evaluable `e`; Clause 9 exceptional-value and error-precedence rows remain under audit |
 | 5.5.11 reserved atoms | not applicable | EyeProlog declares no reserved-atom extension; extension names remain ordinary atoms unless used in a documented syntactic/predicate/directive role |
 

package/test/conformance/README.md

@@ -23,10 +23,10 @@ profile and implementation extensions. The default registry covers the exact
 predicate indicators listed in Appendix B of the book across the Part 1 strict-core
 target and the normal-mode module/DCG compatibility families. [ISO-COMPLIANCE.md](ISO-COMPLIANCE.md) is the explicit
 release-facing ledger for the Part 1 strict-core audit. This suite is
-still not an independent certification of every processor requirement, lexical
-edge, or option combination. The 8.2-8.5 and 8.15-8.17 built-in slices are now
-tracked one prescribed mode/error row at a time; 8.6-8.14 and the remaining
-processor semantics stay explicitly open in the dedicated audit files. Cases under `iso/`
+still not an independent certification of every processor requirement or lexical
+edge. The complete 8.2-8.17 built-in family is now tracked one prescribed
+mode/error row at a time; the remaining Clause 6/7/9 and processor semantics
+stay explicitly open in the dedicated audit files. Cases under `iso/`
 identify standards-derived behavior; other directories cover EyeProlog host
 contracts and extensions. EyeProlog-only execution features such as automatic
 tabling and `tnot/1` well-founded negation are outside the Part 1 strict-core

package/test/run-iso-strict.mjs

@@ -237,7 +237,7 @@ export function runIsoStrict(reporter = new TestReporter()) {
     includes(error.message, 'alias(user_input)', 'alias option culprit');
   });
 
-  reporter.test('follows the ISO 8.14.1.3 read_term/3 error order', () => {
+  reporter.test('covers ISO 8.14.1.3 read_term/3 errors and selected overlaps', () => {
     equal(capture(() => run('', { isoStrict: true, goal: 'read_term(f(a),_,[X])' })).formal,
       'instantiation_error', 'partial/variable option before stream domain');
     equal(capture(() => run('', { isoStrict: true, goal: 'read_term(f(a),_,foo)' })).formal,
@@ -258,7 +258,7 @@ export function runIsoStrict(reporter = new TestReporter()) {
     equal(solver.io.resolve('user_input').position, 0, 'invalid options are rejected before input');
   });
 
-  reporter.test('follows the ISO 8.14.2.3 write_term/3 error order', () => {
+  reporter.test('covers ISO 8.14.2.3 write_term/3 errors and selected overlaps', () => {
     equal(capture(() => run('', { isoStrict: true, goal: 'write_term(f(a),a,[X])' })).formal,
       'instantiation_error', 'partial/variable option before stream domain');
     equal(capture(() => run('', { isoStrict: true, goal: 'write_term(f(a),a,foo)' })).formal,
@@ -271,7 +271,7 @@ export function runIsoStrict(reporter = new TestReporter()) {
       'domain_error(write_option)', 'invalid option before stream permission');
   });
 
-  reporter.test('follows the ISO 8.14.3.3 op/3 error order', () => {
+  reporter.test('covers ISO 8.14.3.3 op/3 errors and selected overlaps', () => {
     equal(capture(() => run('', { isoStrict: true, goal: 'op(a,X,0)' })).formal,
       'instantiation_error', 'specifier variable before priority type');
     equal(capture(() => run('', { isoStrict: true, goal: 'op(a,xfy,[X])' })).formal,
@@ -297,7 +297,7 @@ export function runIsoStrict(reporter = new TestReporter()) {
       'type_error(atom)', 'operator type');
   });
 
-  reporter.test('follows remaining Part 1 built-in error precedence', () => {
+  reporter.test('covers remaining Part 1 built-in error conditions and overlap choices', () => {
     const cases = [
       ['arg(a,X,_)', 'instantiation_error', 'arg/3 second-argument instantiation before index type'],
       ['atom_concat(1,X,Y)', 'instantiation_error', 'atom_concat/3 second/whole under-instantiation before first type'],
@@ -317,9 +317,9 @@ export function runIsoStrict(reporter = new TestReporter()) {
   });
 
   reporter.test('orders input-code representation errors after stream diagnostics', () => {
-    // ISO 8.12.1.3/8.12.2.3: Code's integer type is checked early, but an
-    // integer outside the in-character-code domain is the final listed error.
-    // It must therefore not mask output/binary/past-EOF/entity errors.
+    // Keep EyeProlog's selected 8.12 overlap behavior stable: integer type
+    // errors are detected before stream access, while a valid integer outside
+    // the in-character-code domain is diagnosed after stream/entity errors.
     for (const predicate of ['get_code', 'peek_code']) {
       equal(capture(() => run('', { isoStrict: true, goal: `${predicate}(user_output,-2)` })).formal,
         'permission_error(input, stream)', `${predicate}/2 output stream before bad code`);
@@ -354,6 +354,216 @@ export function runIsoStrict(reporter = new TestReporter()) {
       'representation_error(in_character_code)', 'bad code once no earlier stream error applies');
   });
 
+  reporter.test('closes the ISO 8.11 stream selection/control rows', () => {
+    const errors = [
+      ['current_input(foo)', 'domain_error(stream)', 'current_input/1 stream term'],
+      ['current_output(foo)', 'domain_error(stream)', 'current_output/1 stream term'],
+      ['set_input(X)', 'instantiation_error', 'set_input/1 variable'],
+      ['set_input(f(a))', 'domain_error(stream_or_alias)', 'set_input/1 stream-or-alias domain'],
+      ['set_input(no_such_stream)', 'existence_error(stream)', 'set_input/1 closed/missing stream'],
+      ['set_input(user_output)', 'permission_error(input, stream)', 'set_input/1 output stream'],
+      ['set_output(X)', 'instantiation_error', 'set_output/1 variable'],
+      ['set_output(f(a))', 'domain_error(stream_or_alias)', 'set_output/1 stream-or-alias domain'],
+      ['set_output(no_such_stream)', 'existence_error(stream)', 'set_output/1 closed/missing stream'],
+      ['set_output(user_input)', 'permission_error(output, stream)', 'set_output/1 input stream'],
+      ['open(X,read,S,[])', 'instantiation_error', 'open/4 source instantiation'],
+      ['open(dummy,X,S,[])', 'instantiation_error', 'open/4 mode instantiation'],
+      ['open(dummy,read,S,[X])', 'instantiation_error', 'open/4 option instantiation'],
+      ['open(dummy,1,S,[])', 'type_error(atom)', 'open/4 mode type'],
+      ['open(dummy,read,S,foo)', 'type_error(list)', 'open/4 options list type'],
+      ['open(dummy,read,already_bound,[])', 'uninstantiation_error', 'open/4 stream output mode'],
+      ['open(4,read,S,[])', 'domain_error(source_sink)', 'open/4 source/sink domain'],
+      ['open(dummy,bad,S,[])', 'domain_error(io_mode)', 'open/4 io mode domain'],
+      ['open(dummy,write,S,[bogus])', 'domain_error(stream_option)', 'open/4 stream option domain'],
+      ['close(X,[])', 'instantiation_error', 'close/2 stream instantiation'],
+      ['close(no_such_stream,[X])', 'instantiation_error', 'close/2 option instantiation'],
+      ['close(no_such_stream,foo)', 'type_error(list)', 'close/2 options list type'],
+      ['close(f(a),[])', 'domain_error(stream_or_alias)', 'close/2 stream-or-alias domain'],
+      ['close(no_such_stream,[bogus])', 'domain_error(close_option)', 'close/2 close option domain'],
+      ['close(no_such_stream,[])', 'existence_error(stream)', 'close/2 missing stream'],
+      ['flush_output(X)', 'instantiation_error', 'flush_output/1 variable'],
+      ['flush_output(f(a))', 'domain_error(stream_or_alias)', 'flush_output/1 stream-or-alias domain'],
+      ['flush_output(no_such_stream)', 'existence_error(stream)', 'flush_output/1 missing stream'],
+      ['flush_output(user_input)', 'permission_error(output, stream)', 'flush_output/1 input stream'],
+      ['stream_property(foo,P)', 'domain_error(stream)', 'stream_property/2 stream term domain'],
+      ['stream_property(S,bogus)', 'domain_error(stream_property)', 'stream_property/2 property domain'],
+      ['at_end_of_stream(X)', 'instantiation_error', 'at_end_of_stream/1 variable'],
+      ['at_end_of_stream(f(a))', 'domain_error(stream_or_alias)', 'at_end_of_stream/1 stream-or-alias domain'],
+      ['at_end_of_stream(no_such_stream)', 'existence_error(stream)', 'at_end_of_stream/1 missing stream'],
+      ['set_stream_position(X,0)', 'instantiation_error', 'set_stream_position/2 stream instantiation'],
+      ['set_stream_position(user_input,X)', 'instantiation_error', 'set_stream_position/2 position instantiation'],
+      ['set_stream_position(f(a),0)', 'domain_error(stream_or_alias)', 'set_stream_position/2 stream-or-alias domain'],
+      ['set_stream_position(user_input,foo)', 'domain_error(stream_position)', 'set_stream_position/2 position domain'],
+      ['set_stream_position(no_such_stream,0)', 'existence_error(stream)', 'set_stream_position/2 missing stream'],
+      ['set_stream_position(user_input,0)', 'permission_error(reposition, stream)', 'set_stream_position/2 non-repositionable stream'],
+    ];
+    for (const [goal, formal, label] of errors) {
+      equal(capture(() => run('', { isoStrict: true, goal })).formal, formal, label);
+    }
+
+    equal(run('', { isoStrict: true, goal: 'current_input(S),stream_property(S,input)' }).stats.completed_goal_lists, 1,
+      'current_input/1 successful mode');
+    equal(run('', { isoStrict: true, goal: 'current_output(S),stream_property(S,output)' }).stats.completed_goal_lists, 1,
+      'current_output/1 successful mode');
+    equal(run('', { isoStrict: true, goal: 'flush_output(user_output)' }).stats.completed_goal_lists, 1,
+      'flush_output/1 successful mode');
+    equal(run('', { isoStrict: true, goal: 'at_end_of_stream(user_input)' }).stats.completed_goal_lists, 1,
+      'at_end_of_stream/1 at empty standard input');
+
+    const openErrorSolver = new Solver(Program.parse('', { isoStrict: true }), { isoStrict: true });
+    openErrorSolver.io.open = () => { throw Object.assign(new Error('missing'), { code: 'ENOENT' }); };
+    equal(capture(() => [...openErrorSolver.solve([
+      parseGoalText('open(missing,read,S,[])', { isoStrict: true }),
+    ], new Env(), 0)]).formal, 'existence_error(source_sink)', 'open/4 missing read source');
+    openErrorSolver.io.open = () => { throw new Error('denied'); };
+    equal(capture(() => [...openErrorSolver.solve([
+      parseGoalText('open(denied,write,S,[])', { isoStrict: true }),
+    ], new Env(), 0)]).formal, 'permission_error(open, source_sink)', 'open/4 cannot open sink');
+
+    const closedSolver = new Solver(Program.parse('', { isoStrict: true }), { isoStrict: true });
+    const closed = closedSolver.io.add({
+      id: 2, alias: 'closed_stream', mode: 'read', type: 'text', content: 'a', position: 0, path: '',
+      reposition: true, eofAction: 'error', standard: false, pastEnd: false,
+    });
+    closedSolver.io.discard(closed);
+    equal([...closedSolver.solve([
+      parseGoalText("stream_property('$stream'(2),_)", { isoStrict: true }),
+    ], new Env(), 0)].length, 0, 'closed valid stream-term has no current stream property');
+
+    const positionedSolver = new Solver(Program.parse('', { isoStrict: true }), { isoStrict: true });
+    positionedSolver.io.add({
+      id: 2, alias: 'positioned', mode: 'read', type: 'text', content: 'ab', position: 0, path: '',
+      reposition: true, eofAction: 'error', standard: false, pastEnd: false,
+    });
+    equal([...positionedSolver.solve([
+      parseGoalText('set_stream_position(positioned,1)', { isoStrict: true }),
+      parseGoalText("get_char(positioned,'b')", { isoStrict: true }),
+    ], new Env(), 0)].length, 1, 'set_stream_position/2 successful mode');
+  });
+
+  reporter.test('closes the ISO 8.12-8.14 character, byte, and term-I/O rows', () => {
+    const errors = [
+      ['get_char(S,C)', 'instantiation_error', 'get_char/2 stream instantiation'],
+      ['get_char(user_input,ab)', 'type_error(in_character)', 'get_char/2 in-character type'],
+      ['get_char(f(a),C)', 'domain_error(stream_or_alias)', 'get_char/2 stream-or-alias domain'],
+      ['get_char(no_such_stream,C)', 'existence_error(stream)', 'get_char/2 missing stream'],
+      ['get_char(user_output,C)', 'permission_error(input, stream)', 'get_char/2 output stream'],
+      ['get_code(S,C)', 'instantiation_error', 'get_code/2 stream instantiation'],
+      ['get_code(user_input,foo)', 'type_error(integer)', 'get_code/2 integer type'],
+      ['get_code(f(a),C)', 'domain_error(stream_or_alias)', 'get_code/2 stream-or-alias domain'],
+      ['get_code(no_such_stream,C)', 'existence_error(stream)', 'get_code/2 missing stream'],
+      ['get_code(user_output,C)', 'permission_error(input, stream)', 'get_code/2 output stream'],
+      ['get_code(-2)', 'representation_error(in_character_code)', 'get_code/1 in-character-code representation'],
+      ['peek_char(S,C)', 'instantiation_error', 'peek_char/2 stream instantiation'],
+      ['peek_char(user_input,ab)', 'type_error(in_character)', 'peek_char/2 in-character type'],
+      ['peek_code(user_input,foo)', 'type_error(integer)', 'peek_code/2 integer type'],
+      ['put_char(S,a)', 'instantiation_error', 'put_char/2 stream instantiation'],
+      ['put_char(X)', 'instantiation_error', 'put_char/1 character instantiation'],
+      ['put_char(ab)', 'type_error(character)', 'put_char/1 character type'],
+      ['put_char(f(a),a)', 'domain_error(stream_or_alias)', 'put_char/2 stream-or-alias domain'],
+      ['put_char(no_such_stream,a)', 'existence_error(stream)', 'put_char/2 missing stream'],
+      ['put_char(user_input,a)', 'permission_error(output, stream)', 'put_char/2 input stream'],
+      ['put_code(S,97)', 'instantiation_error', 'put_code/2 stream instantiation'],
+      ['put_code(X)', 'instantiation_error', 'put_code/1 code instantiation'],
+      ['put_code(foo)', 'type_error(integer)', 'put_code/1 integer type'],
+      ['put_code(f(a),97)', 'domain_error(stream_or_alias)', 'put_code/2 stream-or-alias domain'],
+      ['put_code(no_such_stream,97)', 'existence_error(stream)', 'put_code/2 missing stream'],
+      ['put_code(user_input,97)', 'permission_error(output, stream)', 'put_code/2 input stream'],
+      ['put_code(1114112)', 'representation_error(character_code)', 'put_code/1 character-code representation'],
+      ['nl(S)', 'instantiation_error', 'nl/1 stream instantiation'],
+      ['nl(f(a))', 'domain_error(stream_or_alias)', 'nl/1 stream-or-alias domain'],
+      ['nl(no_such_stream)', 'existence_error(stream)', 'nl/1 missing stream'],
+      ['nl(user_input)', 'permission_error(output, stream)', 'nl/1 input stream'],
+      ['get_byte(S,B)', 'instantiation_error', 'get_byte/2 stream instantiation'],
+      ['get_byte(256)', 'type_error(in_byte)', 'get_byte/1 in-byte type'],
+      ['get_byte(f(a),B)', 'domain_error(stream_or_alias)', 'get_byte/2 stream-or-alias domain'],
+      ['get_byte(no_such_stream,B)', 'existence_error(stream)', 'get_byte/2 missing stream'],
+      ['get_byte(user_output,B)', 'permission_error(input, stream)', 'get_byte/2 output stream'],
+      ['get_byte(B)', 'permission_error(input, text_stream)', 'get_byte/1 text stream'],
+      ['peek_byte(S,B)', 'instantiation_error', 'peek_byte/2 stream instantiation'],
+      ['peek_byte(256)', 'type_error(in_byte)', 'peek_byte/1 in-byte type'],
+      ['put_byte(S,1)', 'instantiation_error', 'put_byte/2 stream instantiation'],
+      ['put_byte(X)', 'instantiation_error', 'put_byte/1 byte instantiation'],
+      ['put_byte(256)', 'type_error(byte)', 'put_byte/1 byte type'],
+      ['put_byte(f(a),1)', 'domain_error(stream_or_alias)', 'put_byte/2 stream-or-alias domain'],
+      ['put_byte(no_such_stream,1)', 'existence_error(stream)', 'put_byte/2 missing stream'],
+      ['put_byte(user_input,1)', 'permission_error(output, stream)', 'put_byte/2 input stream'],
+      ['put_byte(1)', 'permission_error(output, text_stream)', 'put_byte/1 text stream'],
+      ['read_term(S,T,[])', 'instantiation_error', 'read_term/3 stream instantiation'],
+      ['read_term(f(a),T,[])', 'domain_error(stream_or_alias)', 'read_term/3 stream-or-alias domain'],
+      ['read_term(T,foo)', 'type_error(list)', 'read_term/2 options list type'],
+      ['read_term(T,[bogus])', 'domain_error(read_option)', 'read_term/2 read option domain'],
+      ['read_term(no_such_stream,T,[])', 'existence_error(stream)', 'read_term/3 missing stream'],
+      ['read_term(user_output,T,[])', 'permission_error(input, stream)', 'read_term/3 output stream'],
+      ['write_term(S,a,[])', 'instantiation_error', 'write_term/3 stream instantiation'],
+      ['write_term(f(a),a,[])', 'domain_error(stream_or_alias)', 'write_term/3 stream-or-alias domain'],
+      ['write_term(a,foo)', 'type_error(list)', 'write_term/2 options list type'],
+      ['write_term(a,[bogus])', 'domain_error(write_option)', 'write_term/2 write option domain'],
+      ['write_term(no_such_stream,a,[])', 'existence_error(stream)', 'write_term/3 missing stream'],
+      ['write_term(user_input,a,[])', 'permission_error(output, stream)', 'write_term/3 input stream'],
+      ["op(100,xfy,',')", 'permission_error(modify, operator)', 'op/3 protects comma'],
+      ['current_op(a,_,_)', 'domain_error(operator_priority)', 'current_op/3 priority domain'],
+      ['current_op(1,1,_)', 'domain_error(operator_specifier)', 'current_op/3 specifier domain'],
+      ['current_op(1,fx,1)', 'type_error(atom)', 'current_op/3 operator type'],
+      ['char_conversion(X,a)', 'instantiation_error', 'char_conversion/2 input instantiation'],
+      ['char_conversion(a,X)', 'instantiation_error', 'char_conversion/2 output instantiation'],
+      ['char_conversion(ab,a)', 'representation_error(character)', 'char_conversion/2 input representation'],
+      ['char_conversion(a,ab)', 'representation_error(character)', 'char_conversion/2 output representation'],
+      ['current_char_conversion(ab,X)', 'type_error(character)', 'current_char_conversion/2 input type'],
+      ['current_char_conversion(a,ab)', 'type_error(character)', 'current_char_conversion/2 output type'],
+    ];
+    for (const [goal, formal, label] of errors) {
+      equal(capture(() => run('', { isoStrict: true, goal })).formal, formal, label);
+    }
+
+    const binaryInput = new Solver(Program.parse('', { isoStrict: true }), { isoStrict: true });
+    binaryInput.io.add({
+      id: 2, alias: 'bin_in', mode: 'read', type: 'binary', content: [65], position: 0, path: '',
+      reposition: false, eofAction: 'error', standard: false, pastEnd: false,
+    });
+    for (const goal of ['get_char(bin_in,C)', 'get_code(bin_in,C)', 'peek_char(bin_in,C)', 'peek_code(bin_in,C)', 'read_term(bin_in,T,[])']) {
+      equal(capture(() => [...binaryInput.solve([parseGoalText(goal, { isoStrict: true })], new Env(), 0)]).formal,
+        'permission_error(input, binary_stream)', `${goal} binary stream`);
+    }
+    equal([...binaryInput.solve([parseGoalText('peek_byte(bin_in,65)', { isoStrict: true })], new Env(), 0)].length, 1,
+      'peek_byte/2 successful binary mode');
+    equal([...binaryInput.solve([parseGoalText('get_byte(bin_in,65)', { isoStrict: true })], new Env(), 0)].length, 1,
+      'get_byte/2 successful binary mode');
+
+    const binaryOutput = new Solver(Program.parse('', { isoStrict: true }), { isoStrict: true });
+    binaryOutput.io.add({
+      id: 2, alias: 'bin_out', mode: 'write', type: 'binary', content: [], position: 0, path: '',
+      reposition: false, eofAction: 'error', standard: false, pastEnd: false,
+    });
+    for (const goal of ['put_char(bin_out,a)', 'put_code(bin_out,97)', 'nl(bin_out)', 'write_term(bin_out,a,[])']) {
+      equal(capture(() => [...binaryOutput.solve([parseGoalText(goal, { isoStrict: true })], new Env(), 0)]).formal,
+        'permission_error(output, binary_stream)', `${goal} binary stream`);
+    }
+    equal([...binaryOutput.solve([parseGoalText('put_byte(bin_out,65)', { isoStrict: true })], new Env(), 0)].length, 1,
+      'put_byte/2 successful binary mode');
+
+    const pastInput = new Solver(Program.parse('', { isoStrict: true }), { isoStrict: true });
+    pastInput.io.add({
+      id: 2, alias: 'past_in', mode: 'read', type: 'text', content: '', position: 0, path: '',
+      reposition: false, eofAction: 'error', standard: false, pastEnd: true,
+    });
+    for (const goal of ['get_char(past_in,C)', 'get_code(past_in,C)', 'peek_char(past_in,C)', 'peek_code(past_in,C)', 'read_term(past_in,T,[])']) {
+      equal(capture(() => [...pastInput.solve([parseGoalText(goal, { isoStrict: true })], new Env(), 0)]).formal,
+        'permission_error(input, past_end_of_stream)', `${goal} past EOF`);
+    }
+
+    equal(capture(() => run('', {
+      isoStrict: true,
+      goal: 'read_term(T,[])',
+      ioOptions: { input: "'unterminated." },
+    })).formal, 'syntax_error(read_term)', 'read_term/2 syntax error');
+
+    equal(run('', { isoStrict: true, goal: "char_conversion(a,b),current_char_conversion(a,b)" }).stats.completed_goal_lists, 1,
+      'char_conversion/2 and current_char_conversion/2 successful mode');
+    equal(run('', { isoStrict: true, goal: 'op(100,xf,zz),current_op(100,xf,zz)' }).stats.completed_goal_lists, 1,
+      'op/3 and current_op/3 successful mode');
+  });
+
   reporter.test('treats close force(true) as presence-based', () => {
     const closeWith = (options) => {
       const solver = new Solver(Program.parse('', { isoStrict: true }), { isoStrict: true });
@@ -481,12 +691,12 @@ export function runIsoStrict(reporter = new TestReporter()) {
     }
   });
 
-  reporter.test('follows ISO clause/2 private-procedure error precedence', () => {
+  reporter.test('keeps the selected clause/2 private-procedure overlap behavior', () => {
     equal(capture(() => run('p.\n', { isoStrict: true, goal: 'clause(atom(_),4)' })).formal,
       'permission_error(access, private_procedure)', 'private procedure before body callability');
   });
 
-  reporter.test('validates all-solutions goals before their output lists', () => {
+  reporter.test('keeps the selected all-solutions Goal-before-Instances overlap behavior', () => {
     for (const predicate of ['findall', 'bagof', 'setof']) {
       equal(capture(() => run('', { isoStrict: true, goal: `${predicate}(X,Y,foo)` })).formal,
         'instantiation_error', `${predicate}/3 variable goal`);
@@ -700,6 +910,93 @@ export function runIsoStrict(reporter = new TestReporter()) {
     }
   });
 
+  reporter.test('closes the ISO 8.6-8.10 prescribed mode/error rows', () => {
+    const errors = [
+      ['X is Y', 'instantiation_error', 'is/2 variable expression'],
+      ['X is foo', 'type_error(evaluable)', 'is/2 expression evaluation error'],
+      ['X =:= 1', 'instantiation_error', '=:=/2 left variable'],
+      ['1 =:= X', 'instantiation_error', '=:=/2 right variable'],
+      ['X =\\= 1', 'instantiation_error', '=\\=/2 left variable'],
+      ['1 < X', 'instantiation_error', '</2 right variable'],
+      ['X =< 1', 'instantiation_error', '=</2 left variable'],
+      ['1 > X', 'instantiation_error', '>/2 right variable'],
+      ['X >= 1', 'instantiation_error', '>=/2 left variable'],
+      ['foo =:= 1', 'type_error(evaluable)', 'arithmetic comparison evaluation error'],
+      ['clause(X,_)', 'instantiation_error', 'clause/2 variable head'],
+      ['clause(4,_)', 'type_error(callable)', 'clause/2 head type'],
+      ['current_predicate(4)', 'type_error(predicate_indicator)', 'current_predicate/1 indicator type'],
+      ['asserta(_)', 'instantiation_error', 'asserta/1 variable head'],
+      ['asserta(4)', 'type_error(callable)', 'asserta/1 head type'],
+      ['asserta((p:-4))', 'type_error(callable)', 'asserta/1 body conversion'],
+      ['assertz(_)', 'instantiation_error', 'assertz/1 variable head'],
+      ['assertz(4)', 'type_error(callable)', 'assertz/1 head type'],
+      ['assertz((p:-4))', 'type_error(callable)', 'assertz/1 body conversion'],
+      ['retract(_)', 'instantiation_error', 'retract/1 variable head'],
+      ['retract(4)', 'type_error(callable)', 'retract/1 head type'],
+      ['retractall(_)', 'instantiation_error', 'retractall/1 variable head'],
+      ['retractall(4)', 'type_error(callable)', 'retractall/1 head type'],
+      ['abolish(X)', 'instantiation_error', 'abolish/1 variable indicator'],
+      ['abolish(foo/X)', 'instantiation_error', 'abolish/1 variable arity'],
+      ['abolish(foo)', 'type_error(predicate_indicator)', 'abolish/1 indicator type'],
+      ['abolish(foo/a)', 'type_error(integer)', 'abolish/1 arity type'],
+      ['abolish(4/1)', 'type_error(atom)', 'abolish/1 name type'],
+      ['abolish(foo/(-1))', 'domain_error(not_less_than_zero)', 'abolish/1 negative arity'],
+      ['findall(X,Y,L)', 'instantiation_error', 'findall/3 variable goal'],
+      ['findall(X,4,L)', 'type_error(callable)', 'findall/3 goal type'],
+      ['findall(X,true,foo)', 'type_error(list)', 'findall/3 Instances type'],
+      ['bagof(X,Y,L)', 'instantiation_error', 'bagof/3 variable iterated goal'],
+      ['bagof(X,4,L)', 'type_error(callable)', 'bagof/3 iterated-goal type'],
+      ['bagof(X,true,foo)', 'type_error(list)', 'bagof/3 Instances type'],
+      ['setof(X,Y,L)', 'instantiation_error', 'setof/3 variable iterated goal'],
+      ['setof(X,4,L)', 'type_error(callable)', 'setof/3 iterated-goal type'],
+      ['setof(X,true,foo)', 'type_error(list)', 'setof/3 Instances type'],
+    ];
+    for (const [goal, formal, label] of errors) {
+      equal(capture(() => run('', { isoStrict: true, goal })).formal, formal, label);
+    }
+
+    for (const goal of [
+      'X is 1+2, X=3',
+      '1 =:= 1',
+      '1 =\\= 2',
+      '1 < 2',
+      '1 =< 1',
+      '2 > 1',
+      '2 >= 2',
+      'findall(X,(X=1;X=2),[1,2])',
+      'bagof(X,(X=1;X=2),[1,2])',
+      'setof(X,(X=2;X=1;X=2),[1,2])',
+    ]) {
+      equal(run('', { isoStrict: true, goal }).stats.completed_goal_lists > 0, true, `${goal} successful mode`);
+    }
+    equal(run('', { isoStrict: true, goal: '4 is 1+2' }).stats.completed_goal_lists, 0, 'is/2 failed unification');
+    equal(run('', { isoStrict: true, goal: 'bagof(X,fail,L)' }).stats.completed_goal_lists, 0, 'bagof/3 empty solution set fails');
+    equal(run('', { isoStrict: true, goal: 'setof(X,fail,L)' }).stats.completed_goal_lists, 0, 'setof/3 empty solution set fails');
+
+    const current = run('p(a).\nq.\n', { isoStrict: true, goal: 'current_predicate(p/1)' });
+    equal(current.stats.completed_goal_lists, 1, 'current_predicate/1 finds a user procedure');
+  });
+
+  reporter.test('preserves 7.6.2 source-body conversion identity for clause/2 and retract/1', () => {
+    const source = [
+      ':- dynamic(foo/1).',
+      'foo(X) :- X.',
+      ':- dynamic(bar/1).',
+      'bar(X) :- (X ; true).',
+      ':- dynamic(baz/1).',
+      'baz(X) :- (X -> true).',
+      '',
+    ].join('\n');
+    equal(run(source, { isoStrict: true, goal: 'clause(foo(C),call(C))' }).stats.completed_goal_lists, 1,
+      'variable body converts to call/1 with head sharing');
+    equal(run(source, { isoStrict: true, goal: 'clause(bar(C),(call(C);true))' }).stats.completed_goal_lists, 1,
+      'disjunction recursively converts a variable branch');
+    equal(run(source, { isoStrict: true, goal: 'clause(baz(C),(call(C)->true))' }).stats.completed_goal_lists, 1,
+      'if-then recursively converts a variable branch');
+    equal(run(source, { isoStrict: true, goal: 'retract((foo(C):-call(C)))' }).stats.completed_goal_lists, 1,
+      'retract/1 sees the converted body with shared variables');
+  });
+
   reporter.test('closes the ISO 8.15-8.17 prescribed mode/error rows', () => {
     const cases = [
       ['\\+(X)', 'instantiation_error', '\+/1 variable goal'],