eyeprolog 1.3.55 → 1.3.56

package/package.json

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

package/src/iso.js

@@ -590,12 +590,22 @@ function requireClauseHead(head) {
   if (head.type !== ATOM && head.type !== COMPOUND) throw new PrologError('type_error(callable)', head);
 }
 
-function convertAssertedBody(term) {
+function convertAssertedBody(term, culprit = term) {
   if (term.type === VAR) return compound('call', [term]);
-  if (term.type === COMPOUND && term.name === ',' && term.arity === 2) {
-    return compound(',', [convertAssertedBody(term.args[0]), convertAssertedBody(term.args[1])]);
+  // 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
+  // variables (which become call(Var)) and for invalid nested terms, which
+  // must be rejected while assert[az]/1 performs the conversion rather than
+  // 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),
+    ]);
+  }
+  if (term.type !== ATOM && term.type !== COMPOUND) {
+    throw new PrologError('type_error(callable)', culprit);
   }
-  if (term.type !== ATOM && term.type !== COMPOUND) throw new PrologError('type_error(callable)', term);
   return term;
 }
 

package/src/program.js

@@ -1,6 +1,6 @@
 // Program representation and clause indexing.
 // Indexes are deliberately conservative: they speed up common scalar arguments but never replace unification as the final check.
-import { ATOM, COMPOUND, VAR, Env, atom, compound, deref, flattenConjunction, isScalar, numberTerm, properListItems, termToString, variable } from './term.js';
+import { ATOM, COMPOUND, STRING, VAR, Env, atom, compound, deref, flattenConjunction, isScalar, numberTerm, properListItems, termToString, variable } from './term.js';
 import { formatTermForWrite } from './write.js';
 import {
   ISO_OPERATOR_DEFINITIONS,
@@ -33,6 +33,21 @@ import {
 const DEFER_PROGRAM_BUILD = Symbol('deferProgramBuild');
 const FAST_PARSE_ABORT = Symbol('fastParseAbort');
 const PROGRAM_BUILD_BATCH_SIZE = 16384;
+
+function termContainsStringExtension(term, seen = new Set()) {
+  if (term == null || typeof term !== 'object' || seen.has(term)) return false;
+  seen.add(term);
+  if (term.type === STRING) return true;
+  if (term.type === COMPOUND) return term.args.some((arg) => termContainsStringExtension(arg, seen));
+  return false;
+}
+
+function clauseContainsStringExtension(clause) {
+  if (clause == null) return false;
+  if (clause.head0Type === STRING || clause.head1Type === STRING) return true;
+  if (termContainsStringExtension(clause.head) || termContainsStringExtension(clause.query)) return true;
+  return Array.isArray(clause.body) && clause.body.some((goal) => termContainsStringExtension(goal));
+}
 export class Program {
   constructor(clauses = [], options = {}) {
     this.clauses = [];
@@ -574,6 +589,12 @@ class ProgramBuilder {
     let lastGroup = this.lastGroup;
 
     for (const clause of clauses) {
+      if (program.strictIso && clauseContainsStringExtension(clause)) {
+        // Programmatic clauses are part of the public embedding surface.  The
+        // normal profile permits its host string term extension, but the Part 1
+        // strict profile must reject that implementation-specific sixth type.
+        throw new PrologError('representation_error(term)');
+      }
       if (clause?.kind === 'quad') {
         const module = clause.module ?? 'user';
         annotateGoalModule(clause.query, module);

package/src/solver.js

@@ -1,7 +1,7 @@
 // Depth-first EyeProlog solver with builtin dispatch, memoization, and guarded recursion handling.
 // Most semantic decisions still flow through unification; optimizations only select candidates earlier.
 import {
-  ATOM, COMPOUND, NUMBER, VAR, Env, compactListLength, compactVariableList, compound, cons, copyResolved, deref, emptyList,
+  ATOM, COMPOUND, NUMBER, STRING, VAR, Env, compactListLength, compactVariableList, compound, cons, copyResolved, deref, emptyList,
   flattenConjunction, freshTerm, isCons, isDecimalInteger, isEmptyList,
   numberTerm, numberTextFromDouble, termIsGround, termToString, unify, variable, variantTerms,
 } from './term.js';
@@ -45,6 +45,26 @@ function raiseOccursCheckError(left, right, env) {
   throw error;
 }
 
+
+function rejectStrictIsoStringTerms(terms, env) {
+  const seen = new Set();
+  const visit = (term) => {
+    const resolved = deref(term, env);
+    if (resolved == null || seen.has(resolved)) return;
+    seen.add(resolved);
+    if (resolved.type === STRING) {
+      // `stringTerm()` is a normal-profile host/API term extension.  It has no
+      // Part 1 abstract/token syntax, so strict execution must reject it rather
+      // than silently introducing a sixth term type through the embedding API.
+      throw new PrologError('representation_error(term)');
+    }
+    if (resolved.type === COMPOUND) {
+      for (const arg of resolved.args) visit(arg);
+    }
+  };
+  for (const term of terms) visit(term);
+}
+
 export class Solver {
   constructor(program, options = {}) {
     this.program = program;
@@ -301,6 +321,7 @@ export class Solver {
   *solve(goals, env = new Env(), depth = 0) {
     if (!Array.isArray(goals)) goals = [goals];
     env.setOccursCheckHandler(this.occursCheckHandler);
+    if (this.isoStrict) rejectStrictIsoStringTerms(goals, env);
 
     const writeVariableState = this.writeVariableState;
     if (writeVariableState.depth === 0) {

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

@@ -0,0 +1,205 @@
+# ISO Part 1 built-in mode/error audit
+
+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.
+
+The focused assertions added for this matrix live in `test/run-iso-strict.mjs`;
+existing file-based cases remain additional independent evidence.
+
+## 8.2 — term unification
+
+| Clause / predicate | Prescribed row | Status | Executable evidence |
+| --- | --- | --- | --- |
+| 8.2.1 `(=)/2` | `?term, ?term`; succeeds/fails according to Prolog unification; no prescribed errors | covered | existing unification corpus and `term_modes_and_ordering` |
+| 8.2.2 `unify_with_occurs_check/2` | `?term, ?term`; succeeds/fails and never reports a prescribed error | covered | strict row-audit success assertion plus unification corpus |
+| 8.2.3 `(\=)/2` | `@term, @term`; succeeds/fails for the defined NSTO cases; no prescribed errors | covered | unification/control corpus |
+| Cor.2 8.2.4 `subsumes_term/2` | `@term, @term`; succeeds/fails without binding its arguments; no prescribed errors | covered | strict row-audit success assertion and Corrigendum 2 term-predicate cases |
+
+## 8.3 — type testing
+
+All Part 1 type tests have a single input-term mode and no prescribed errors.
+The Corrigendum 2 additions have the same shape.
+
+| Predicate | Prescribed row | Status | Executable evidence |
+| --- | --- | --- | --- |
+| `var/1` | input term; semidet; no errors | covered | `type_var_success` and term-mode cases |
+| `atom/1` | input term; semidet; no errors | covered | `type_atom_success` |
+| `integer/1` | input term; semidet; no errors | covered | `type_integer_success` |
+| `float/1` | input term; semidet; no errors | covered | `type_float_success` |
+| `atomic/1` | input term; semidet; no errors | covered | `type_atomic_atom_success`, `type_atomic_number_success` |
+| `compound/1` | input term; semidet; no errors | covered | `type_compound_success` |
+| `nonvar/1` | input term; semidet; no errors | covered | `type_nonvar_success` |
+| `number/1` | input term; semidet; no errors | covered | `type_number_integer_success`, `type_number_float_success` |
+| Cor.2 `callable/1` | input term; semidet; no errors | covered | `type_callable_atom_success`, `type_callable_compound_success` |
+| Cor.2 `ground/1` | input term; semidet; no errors | covered | `type_ground_success` |
+| Cor.2 `acyclic_term/1` | input term; semidet; no errors | covered | Corrigendum 2 term-predicate coverage |
+
+## 8.4 — term comparison and sorting
+
+| Clause / predicate | Prescribed row | Status | Executable evidence |
+| --- | --- | --- | --- |
+| 8.4.1 `(@<)/2` | two input terms; semidet; no prescribed errors | covered | standard-order corpus and strict type/collation ordering assertions |
+| 8.4.1 `(@=<)/2` | two input terms; semidet; no prescribed errors | covered | standard-order corpus |
+| 8.4.1 `(==)/2` | two input terms; identity test; no prescribed errors | covered | identity/term-mode corpus |
+| 8.4.1 `(\==)/2` | two input terms; non-identity test; no prescribed errors | covered | identity/term-mode corpus |
+| 8.4.1 `(@>)/2` | two input terms; semidet; no prescribed errors | covered | standard-order corpus |
+| 8.4.1 `(@>=)/2` | two input terms; semidet; no prescribed errors | covered | standard-order corpus |
+| Cor.2 8.4.2 `compare/3` | output-order mode | covered | strict `compare(<,a,b)` / comparison cases |
+| Cor.2 8.4.2 `compare/3` | input-order mode | covered | comparison cases |
+| Cor.2 8.4.2 error (a) | non-variable, non-atom `Order` -> atom type error | covered | strict `compare(1,3,3.0)` |
+| Cor.2 8.4.2 error (b) | atom outside `<`, `=`, `>` -> order domain error | covered | strict `compare(>=,3,3.0)` |
+| Cor.2 8.4.3 `sort/2` | input list -> output list | covered | strict `sort([1,1],[1])` and sorting corpus |
+| Cor.2 8.4.3 `sort/2` | input list + input result list | covered | sorting corpus |
+| Cor.2 8.4.3 error (a) | partial input list -> instantiation error | covered | strict `sort([1|T],_)` |
+| Cor.2 8.4.3 error (b) | non-list input -> list type error | covered | strict `sort(foo,_)` |
+| Cor.2 8.4.3 error (c) | non-list result -> list type error | covered | strict `sort([],foo)` |
+| Cor.2 8.4.4 `keysort/2` | input pairs -> output list | covered | strict `keysort([2-b,1-a],[1-a,2-b])` and Corrigendum cases |
+| Cor.2 8.4.4 `keysort/2` | input pairs + input result list | covered | Corrigendum cases |
+| Cor.2 8.4.4 error (a) | partial `Pairs` -> instantiation error | covered | strict `keysort([1-a|T],_)` |
+| Cor.2 8.4.4 error (b) | non-list `Pairs` -> list type error | covered | strict `keysort(foo,_)` |
+| Cor.2 8.4.4 error (c) | non-list `Sorted` -> list type error | covered | strict `keysort([],foo)` |
+| Cor.2 8.4.4 error (d) | variable element in `Pairs` prefix -> instantiation error | covered | strict `keysort([X],_)` |
+| Cor.2 8.4.4 error (e) | non-pair element in `Pairs` prefix -> pair type error | covered | strict `keysort([foo],_)` |
+| Cor.2 8.4.4 error (f) | non-pair element in `Sorted` prefix -> pair type error | covered | strict `keysort([],[foo])` |
+
+## 8.5 — term creation and decomposition
+
+| Clause / predicate | Prescribed row | Status | Executable evidence |
+| --- | --- | --- | --- |
+| 8.5.1 `functor/3` | decompose a non-variable term | covered | term-construction corpus |
+| 8.5.1 `functor/3` | construct from `Name` and `Arity` | covered | term-construction corpus |
+| 8.5.1 errors (a-b) | missing required `Name` or `Arity` when constructing -> instantiation error | covered | strict `functor(X,Y,3)` and `functor(X,foo,N)` |
+| 8.5.1 error (c) | non-atomic `Name` -> atomic type error | covered | strict `functor(X,foo(a),a)` precedence case |
+| 8.5.1 error (d) | non-integer `Arity` -> integer type error | covered | strict `functor(X,foo,a)` |
+| 8.5.1 error (e) | positive arity with non-atom atomic name -> atom type error | covered | strict `functor(X,1.5,1)` |
+| 8.5.1 error (f) | requested arity above finite `max_arity` | not applicable | EyeProlog selects `max_arity=unbounded`; finite host exhaustion is a resource condition |
+| 8.5.1 error (g) | negative `Arity` -> non-negative domain error | covered | strict `functor(X,foo,-1)` |
+| 8.5.2 `arg/3` | positive integer index + compound term | covered | `logtalk_arg_unification` and strict cases |
+| 8.5.2 error (a) | variable index -> instantiation error | covered | strict `arg(X,foo(a),_)` |
+| 8.5.2 error (b) | variable term -> instantiation error | covered | strict `arg(1,X,_)` |
+| 8.5.2 error (c) | non-integer index -> integer type error | covered | strict `arg(a,foo(a),_)` |
+| 8.5.2 error (d) | non-compound term -> compound type error | covered | strict `arg(0,atom,_)` precedence case |
+| 8.5.2 error (e) | negative index -> non-negative domain error | covered | strict `arg(-1,foo(a),_)` |
+| 8.5.3 `(=..)/2` | term -> list decomposition | covered | `logtalk_univ` and term-construction cases |
+| 8.5.3 `(=..)/2` | list -> term construction | covered | `logtalk_univ` and term-construction cases |
+| 8.5.3 error (a) | both arguments insufficiently instantiated | covered | strict `X=..Y` |
+| 8.5.3 error (b) | partial list in construction direction | covered | strict `X=..[foo|T]` |
+| 8.5.3 error (c) | non-list second argument | covered | strict `X=..foo` |
+| 8.5.3 error (d) | variable list head | covered | strict `X=..[F,a]` |
+| 8.5.3 error (e) | invalid compound functor/list head | covered | strict `X=..[3,a]` and singleton compound-head case |
+| 8.5.3 error (f) | empty construction list | covered | strict `X=..[]` |
+| 8.5.3 finite-arity representation branch | constructed list exceeds finite `max_arity` | not applicable | selected `max_arity=unbounded` |
+| 8.5.4 `copy_term/2` | copy with fresh variables | covered | strict success assertion, `copy_term_fresh_variables`, `logtalk_copy_term_semantics` |
+| Cor.2 8.5.5 `term_variables/2` | output witness-variable list | covered | strict `term_variables(A+B+B,[A,B])`, Logtalk-derived cases |
+| 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.15 — logic and control
+
+| Clause / predicate | Prescribed row | Status | Executable evidence |
+| --- | --- | --- | --- |
+| 8.15.1 `(\+)/1` | callable goal; semidet | covered | negation corpus |
+| 8.15.1 error (a) | variable goal -> instantiation error | covered | strict `\+(X)` |
+| 8.15.1 error (b) | non-callable goal -> callable type error | covered | strict `\+(3)` |
+| 8.15.2 `once/1` | callable goal; only first solution survives | covered | direct strict solver assertion, `once_commits_first`, `logtalk_once` |
+| 8.15.2 error (a) | variable goal -> instantiation error | covered | strict `once(X)` |
+| 8.15.2 error (b) | non-callable goal -> callable type error | covered | strict `once(3)` |
+| 8.15.3 `repeat/0` | repeatedly succeeds; no prescribed errors | covered | `logtalk_repeat` |
+| Cor.2 8.15.4 `call/2..8` | closure expansion through the standardized maximum arity | covered | direct strict closure assertion and `corrigenda_call_closure` |
+| Cor.2 8.15.4 error (a) | variable closure -> instantiation error | covered | strict `call(X,a)` |
+| Cor.2 8.15.4 error (b) | non-callable closure -> callable type error | covered | strict `call(3,a)` |
+| Cor.2 8.15.4 finite-`max_arity` branch | resulting goal exceeds finite `max_arity` | not applicable | selected `max_arity=unbounded`; branch remains implementation-tested conditionally |
+| Cor.2 8.15.4 implementation-dependent `call/N`, N>=9 | EyeProlog supplies no additional standardized closure arities | covered | strict `call(foo,a,b,c,d,e,f,g,h)` reaches procedure-existence handling rather than an extra call/N built-in |
+| Cor.2 8.15.4 resulting-goal conversion error | expanded goal cannot be converted to a callable goal | covered | strict callability/error tests |
+| Cor.2 8.15.5 `false/0` | always fails; no prescribed errors | covered | strict assertion and `false_builtin` |
+
+## 8.16 — atomic term processing
+
+| Clause / predicate | Prescribed row | Status | Executable evidence |
+| --- | --- | --- | --- |
+| 8.16.1 `atom_length/2` | atom -> length / check supplied length | covered | `logtalk_atom_length`, strict row audit |
+| 8.16.1 error: atom variable | required atom unavailable -> instantiation error | covered | strict `atom_length(X,4)` |
+| 8.16.1 error: atom type | first argument non-atom -> atom type error | covered | strict `atom_length(1.2,4)` |
+| 8.16.1 error: length type | non-integer length -> integer type error | covered | strict `atom_length(atom,'4')` |
+| 8.16.1 error: length domain | negative length -> non-negative domain error | covered | strict `atom_length(atom,-1)` |
+| 8.16.2 `atom_concat/3` | concatenate known pieces or enumerate splits of known whole | covered | direct strict enumeration assertion and `logtalk_atom_concat` |
+| 8.16.2 errors: insufficient first/whole or second/whole instantiation | instantiation error | covered | strict `atom_concat(X,small,Y)` and `atom_concat(small,X,Y)` |
+| 8.16.2 errors: atom types | non-atom in each fixed position -> atom type error | covered | three strict type assertions |
+| 8.16.3 `sub_atom/5` | enumerate/check source slices | covered | direct strict six-slice assertion and `logtalk_sub_atom` |
+| 8.16.3 error: source variable | instantiation error | covered | strict `sub_atom(X,0,1,0,a)` |
+| 8.16.3 errors: atom types | source/result non-atom -> atom type error | covered | strict source/result assertions |
+| 8.16.3 errors: integer types | fixed Before/Length/After non-integer -> integer type error | covered | three strict assertions |
+| 8.16.3 errors: non-negative domains | fixed Before/Length/After negative -> domain error | covered | three strict assertions |
+| 8.16.4 `atom_chars/2` | atom <-> list of characters | covered | forward/reverse and Logtalk-derived cases |
+| Cor.2 `atom_chars/2`: both insufficiently instantiated | instantiation error | covered | strict `atom_chars(X,Y)` |
+| Cor.2 `atom_chars/2`: atom type | atom side non-atom | covered | strict `atom_chars(1,[])` |
+| Cor.2 `atom_chars/2`: improper list | list type error on complete list culprit | covered | strict `atom_chars(X,[a|foo])` and focused culprit regressions |
+| Cor.2 `atom_chars/2`: variable list-prefix element | instantiation error | covered | strict `atom_chars(X,[Y,a])` |
+| Cor.2 `atom_chars/2`: non-character element | character type error | covered | strict `atom_chars(X,[a,1])` |
+| 8.16.5 `atom_codes/2` | atom <-> list of character codes | covered | forward/reverse and Logtalk-derived cases |
+| Cor.2 `atom_codes/2`: both insufficiently instantiated | instantiation error | covered | strict `atom_codes(X,Y)` |
+| Cor.2 `atom_codes/2`: atom type | atom side non-atom | covered | strict `atom_codes(1,[])` |
+| Cor.2 `atom_codes/2`: improper list | list type error on complete list culprit | covered | strict `atom_codes(X,[97|foo])` |
+| Cor.2 `atom_codes/2`: variable prefix element | instantiation error | covered | strict `atom_codes(X,[Y,97])` |
+| Cor.2 `atom_codes/2`: code type | non-integer code -> integer type error | covered | strict `atom_codes(X,[97,foo])` |
+| Cor.2 `atom_codes/2`: code representation | integer outside processor character-code set -> representation error | covered | strict `atom_codes(X,[97,-1])` |
+| 8.16.6 `char_code/2` | character <-> character code | covered | forward/reverse cases |
+| 8.16.6 under-instantiation | both sides variable -> instantiation error | covered | strict `char_code(X,Y)` |
+| 8.16.6 character type | non-character first argument takes precedence | covered | strict `char_code(ab,foo)` |
+| 8.16.6 code type | non-integer code -> integer type error | covered | strict `char_code(a,foo)` |
+| 8.16.6 code representation | integer outside processor character-code set -> representation error | covered | strict `char_code(a,-1)` |
+| 8.16.7 `number_chars/2` | number <-> character-list number syntax | covered | number conversion corpus |
+| Cor.2 `number_chars/2`: both insufficiently instantiated | instantiation error | covered | strict `number_chars(X,Y)` |
+| Cor.2 `number_chars/2`: number type | fixed non-number -> number type error | covered | strict `number_chars(foo,[])` |
+| Cor.2 `number_chars/2`: improper list | list type error | covered | strict `number_chars(X,[a|foo])` |
+| Cor.2 `number_chars/2`: variable prefix element | instantiation error | covered | strict `number_chars(X,[Y,a])` |
+| Cor.2 `number_chars/2`: non-character element | character type error | covered | strict `number_chars(X,[a,1])` |
+| `number_chars/2`: invalid number syntax | syntax error | covered | strict `number_chars(X,[a])` and parenthesized-number rejection |
+| 8.16.8 `number_codes/2` | number <-> code-list number syntax | covered | number conversion corpus |
+| Cor.2 `number_codes/2`: both insufficiently instantiated | instantiation error | covered | strict `number_codes(X,Y)` |
+| Cor.2 `number_codes/2`: number type | fixed non-number -> number type error | covered | strict `number_codes(foo,[])` |
+| Cor.2 `number_codes/2`: improper list | list type error | covered | strict `number_codes(X,[49|foo])` |
+| Cor.2 `number_codes/2`: variable prefix element | instantiation error | covered | strict `number_codes(X,[Y,49])` |
+| Cor.2 `number_codes/2`: code type | non-integer code -> integer type error | covered | strict `number_codes(X,[49,foo])` |
+| Cor.2 `number_codes/2`: code representation | integer outside processor character-code set -> representation error | covered | strict `number_codes(X,[49,-1])` |
+| `number_codes/2`: invalid number syntax | syntax error | covered | strict `number_codes(X,[97])` |
+
+## 8.17 — flags and hooks
+
+The complete Part 1 flag family had already been closed before this tranche;
+these rows make the corresponding built-in modes/errors explicit here so the
+built-in matrix does not have a gap at 8.17.
+
+| Clause / predicate | Prescribed row | Status | Executable evidence |
+| --- | --- | --- | --- |
+| 8.17.1 `set_prolog_flag/2` | set a supported, changeable flag value | covered | strict flag audit |
+| 8.17.1 errors | variable/name type/domain, value type/domain, and non-changeable-flag permission distinctions | covered | `covers the Part 1 flag defaults, value domains, and changeability` plus file-based flag errors |
+| 8.17.2 `current_prolog_flag/2` | enumerate/query current standard flags | covered | strict complete flag audit |
+| 8.17.2 flag-name type error | fixed non-atom name -> atom type error | covered | strict `current_prolog_flag(1,_)` |
+| 8.17.2 unknown-flag domain error | fixed unsupported flag name -> Prolog-flag domain error | covered | strict `current_prolog_flag(no_such_iso_flag,_)` |
+| 8.17.3 `halt/0` | terminate with implementation-defined successful host status | covered | `halt` conformance case / host runner tests |
+| 8.17.4 `halt/1` | integer host status | covered | halt conformance/runner tests |
+| 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:
+
+- 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.
+
+Clause 9 exceptional-value rows and Clause 6/7 processor semantics remain
+tracked separately in `ISO-COMPLIANCE.md` and `ISO-PROCESSOR-REQUIREMENTS.md`.

package/test/conformance/ISO-COMPLIANCE.md

@@ -4,8 +4,11 @@ This ledger is the release-facing audit for EyeProlog's ISO/IEC 13211-1 core.
 The normative baseline is ISO/IEC 13211-1:1995 together with Technical
 Corrigenda 1:2007, 2:2012, and 3:2017. It complements
 [ISO-MATRIX.md](ISO-MATRIX.md), which maps standard families to representative
-executable tests, and the generated [`conformance-report.md`](../../conformance-report.md),
-which gives current case totals.
+executable tests, [ISO-BUILTIN-MODE-ERROR-MATRIX.md](ISO-BUILTIN-MODE-ERROR-MATRIX.md),
+which records the row-by-row built-in audit, and
+[ISO-PROCESSOR-REQUIREMENTS.md](ISO-PROCESSOR-REQUIREMENTS.md), which decomposes
+Clause 5 processor obligations. The generated [`conformance-report.md`](../../conformance-report.md)
+gives current case totals.
 
 The ledger deliberately does **not** claim independent certification. A row
 marked `covered` means EyeProlog has implementation and executable tests for
@@ -22,25 +25,25 @@ error-ordering alternative to an individual executable assertion.
 | 5.1(b) execute conforming Prolog goals | audit | Clause 7-9 conformance corpus plus regression/API/example gates. A normative goal-semantics ledger is still being expanded. |
 | 5.1(c) reject nonconforming text/read-terms | audit | Dedicated syntax-error cases and strict-core extension rejection. Exhaustive lexical rejection coverage remains open. |
 | 5.1(d) document permitted variations | covered | The clause-by-clause [ISO 5.4 decision index](ISO-IMPLEMENTATION-DEFINED.md) records every explicit implementation-defined decision found in the Part 1 + Corrigenda baseline and separately inventories implementation-specific extension families. Rows marked `audit gap` remain conformance work, but the variation is no longer undocumented. |
-| 5.1(e) offer a strictly conforming mode | covered | `--iso-strict` and API option `isoStrict: true` restrict the processor to the Part 1 + Corrigenda 1-3 core language surface, remove EyeProlog-only registry/flag/operator features, and disable automatic tabling/recursion guards. |
+| 5.1(e) offer a strictly conforming mode | covered | `--iso-strict` and API option `isoStrict: true` restrict the processor to the Part 1 + Corrigenda 1-3 core language surface, remove EyeProlog-only registry/flag/operator features, disable automatic tabling/recursion guards, and reject the normal-profile host `stringTerm/1` term type at strict program/goal entry. |
 | 5.4 accompanying documentation | covered | *The Art of EyeProlog* remains the implementation reference; [ISO-IMPLEMENTATION-DEFINED.md](ISO-IMPLEMENTATION-DEFINED.md) is the closed clause-by-clause 5.4 decision index and points each decision to implementation evidence or an explicit audit gap. |
-| 5.5 extensions preserve standard text | covered | Default mode retains EyeProlog extensions; strict core mode removes their language/runtime interpretation. Regression tests ensure the default profile remains unchanged. |
+| 5.5 extension boundaries | audit | [ISO-PROCESSOR-REQUIREMENTS.md](ISO-PROCESSOR-REQUIREMENTS.md) now splits 5.5 into its individual extension hooks. Operators, character conversion, the normal-profile host string type, directives, control constructs, flags, and reserved atoms have explicit decisions; exhaustive syntax-preservation, side-effect, built-in, and evaluable-functor dependency mapping remains open. |
 
 ## Normative language families
 
 | Standard area | Status | Current evidence |
 | --- | --- | --- |
 | 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. |
+| 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 now cover `current_predicate/1`, `clause/2`, `asserta/1`, `assertz/1`, `retract/1`, Corrigendum 2 `retractall/1`, and `abolish/1` errors plus empty-procedure lifetime. Runtime protection includes the solver-native conjunction control construct `','/2` and, following STC #56's accepted-direction action item, the source syntax functors `(:-)/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. 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.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. |
+| 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.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. Exact ISO 8.14.1-8.14.4 error precedence is covered for `read_term/3`, `write_term/3`, `op/3`, and `current_op/3`; the continuing audit has corrected additional 8.11-8.13 stream/character/byte errors (including the complete `alias(A)` culprit for `open/4` alias collisions), Corrigendum 2 `keysort/2` errors, atomic-conversion list-shape precedence, `arg/3`, `atom_concat/3`, `sub_atom/5`, `char_conversion/2`, runtime control-construct/database protection, arithmetic culprit/precedence reporting, input-code representation ordering, presence-based close forcing, and host-resource normalization for unbounded term/integer operations. A complete one-row-per-prescribed-error ordering map remains open. |
-| 8.2-8.17 — built-in predicates | audit | Predicate-family coverage is mapped in ISO-MATRIX.md; Corrigendum 2 additions (`subsumes_term/2`, `term_variables/2`, `call/2..8`, `false/0`) are in the strict registry. The audit now includes corrected `keysort/2` variable/non-pair errors, stricter 8.11-8.13 stream and character/byte modes/errors, the 8.14 option/error-order subfamily, closed 8.17 flags, additional prescribed precedence for `arg/3`, `atom_concat/3`, `sub_atom/5`, number/atom list conversions, and `char_conversion/2`, plus finite-host resource handling for unbounded `functor/3` construction and the 8.11/8.12 close/input-code overlap cases. The remaining mode/error matrix is not yet one-row-per-standard-row. |
+| 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. |
 | 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. |
@@ -162,6 +165,28 @@ describes: a later `force(false)` does not cancel an earlier `force(true)` when
 a Resource Error or System Error occurs during closure. Focused strict tests
 cover both overlap families.
 
+The next row-audit tranche makes the remaining exit criterion concrete rather
+than leaving it as a broad test-count claim.
+[ISO-BUILTIN-MODE-ERROR-MATRIX.md](ISO-BUILTIN-MODE-ERROR-MATRIX.md) now records
+each prescribed mode/error row for the 8.2-8.5 and 8.15-8.17 slices, and
+[ISO-PROCESSOR-REQUIREMENTS.md](ISO-PROCESSOR-REQUIREMENTS.md) decomposes the
+Clause 5 obligations into covered, audit, and not-applicable decisions. While
+doing that mapping, the 7.6.2 term-to-clause conversion audit exposed a runtime
+assertion defect: variables and invalid terms nested under `;/2` or `->/2` were
+not being recursively converted. `asserta/1` and `assertz/1` now convert all
+three standardized binary control forms `,/2`, `;/2`, and `->/2` recursively,
+so nested variables become `call/1` and a non-callable nested branch is rejected
+at assertion time with the complete clause-body culprit.
+
+The Clause 5 decomposition also exposed an embedding-only type boundary that
+source-text tests could not see. EyeProlog's normal JavaScript API deliberately
+exports `stringTerm(Text)` as an implementation-specific additional term type.
+Its normal-profile ordering, conversion, evaluation, and writing behavior is
+now documented under 5.5.4, while strict `Program` construction and strict
+`Solver` goal entry reject such terms with `representation_error(term)`. This
+keeps the host extension available in normal mode without allowing it to become
+a sixth term type in the Part 1 strict execution domain.
+
 ## Post-Corrigendum STC cross-check
 
 The public WG17 STC draft is tracked as useful defect-discovery material, but it
@@ -197,7 +222,8 @@ not interpret the following as core-language features:
 - Part 2 module directives (`module/2`, `use_module/1-2`, `meta_predicate/1`);
 - Part 3 grammar-rule expansion and `phrase/2-3`;
 - automatic tabling, cycle guards, and recursive numeric execution shortcuts;
-- EyeProlog well-founded negation via `tnot/1` and its WFS runtime statistics.
+- EyeProlog well-founded negation via `tnot/1` and its WFS runtime statistics;
+- the JavaScript API `stringTerm(Text)` additional term type (normal mode only).
 
 The predefined Part 1 `1200 fx` `?-` operator and `1200 xfx` `-->` operator
 remain ordinary operator syntax in strict core mode. A conforming `op/3`

package/test/conformance/ISO-IMPLEMENTATION-DEFINED.md

@@ -113,7 +113,7 @@ families; `--iso-strict` is intended to remove their Part 1 interpretation.
 | 5.5.1 Syntax | Part 2 modules, Part 3 grammar-rule expansion, and embedded quad syntax | Module directives are rejected; grammar rules remain ordinary `-->/2` terms rather than being expanded; quad syntax is rejected. Unicode PCS membership/classification is implementation defined and therefore shared with normal mode rather than treated as an extension. |
 | 5.5.2 Predefined operators | Part 3 `|` and EyeProlog's labelable infix `(?-)/2`; CLP(Z) operators when that library is imported | Only the Part 1 operator table is predefined; a conforming `op/3` may still add permitted operators. |
 | 5.5.3 Character-conversion mapping | No non-identity initial `Convc` extension | Identity initial mapping. |
-| 5.5.4 Types | No additional runtime Prolog term type is exposed by the core solver | Only variable, integer, float, atom, and compound term ordering participates in strict mode. |
+| 5.5.4 Types | The normal JavaScript API exposes an implementation-specific string term `stringTerm(Text)`. It is disjoint from the five Part 1 term types; normal term order places it after atoms and before compound terms, and normal `atomic/1` treats it as atomic. It has no Prolog source token syntax (double-quoted source still follows `double_quotes`), is non-callable for term-to-clause conversion, is not evaluable as an arithmetic expression, and writes as a double-quoted host string. | Strict mode rejects a programmatic string term at program/goal entry with `representation_error(term)`, so the additional type cannot enter the Part 1 execution domain. **defined** — `src/term.js`, `src/program.js`, `src/solver.js`; strict API-boundary regression. |
 | 5.5.5 Directives | `module/2`, `use_module/1-2`, `meta_predicate/1` and normal-profile library behavior | Rejected as implementation-specific Part 1 directives. |
 | 5.5.6 Side effects | Host output/statistics, library-specific state, proof/statistics collection | The strict registry excludes library adapters; ordinary Part 1 I/O/database/flag/operator side effects remain. |
 | 5.5.7 Control constructs | `tnot/1` and normal-profile execution optimizations | `tnot/1` is absent; automatic tabling/recursion guards are disabled. |

package/test/conformance/ISO-MATRIX.md

@@ -11,13 +11,13 @@ compliance audit and the remaining work before a full conformance claim.
 | Clause 6 lexical and term syntax | tokenizer, operator parser, lists, curly terms, quotes, numeric syntax, comments, Unicode-scalar PCS/collation | `scryer_lexical_terms`, `lexical_and_curly_terms`, `double_quoted_lists`, `corrigendum1_double_quote_operator`, `wg17_syntax_high_risk`, `wg17_invalid_octal_escape`, `wg17_unterminated_quoted_token`, `wg17_literal_newline_in_quote`, `wg17_non_iso_escape`, strict PCS/collation tests in `run-iso-strict.mjs`, syntax error cases |
 | 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, Corrigendum 2 `keysort/2` variable/non-pair errors, and strict `arg/3`, `functor/3` / `=../2` error-order plus unbounded-arity/resource checks |
+| 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, including runtime static/private protection for the solver-native conjunction control construct and STC #56 `(:-)/1-2` database protection |
+| 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.15 logic and control | negation, once, repeat, `call/2` through `call/8`, `false/0` | `logtalk_once`, `corrigenda_call_closure`, `false_builtin`, plus strict Corrigendum 2 resulting-goal `max_arity` error coverage |
-| 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 error cases, strict Corrigendum 2 partial/improper-list precedence for atom/number conversions, and prescribed `atom_concat/3` / `sub_atom/5` ordering checks |
-| 8.17 flags and hooks | complete required Part 1 flag set, selected defaults, standard value domains/changeability, halt and character conversion | `exceptions_and_flags`, `remaining_builtins_and_directives`, flag error cases, strict `char_conversion/2` precedence, and the complete strict flag audit in `run-iso-strict.mjs` |
+| 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` |
 | Clause 9 evaluable functors | integer, float, rounding, transcendental and bitwise operations | `arithmetic`, `corrigenda_arithmetic`, `corrigenda_atan2_zero`, `corrigenda_integer_negative_power`, strict exclusion of the normal-mode `e` evaluable extension, zero-arity unknown-evaluable checks, prescribed operand/type and power-error precedence, float-only rounding modes, I->F overflow before floating functors, explicit `exp/1`/`**/2`/`^/2` underflow, Part 1 mixed integer/float comparison conversion, and resource-error normalization for finite-host exhaustion of unbounded integer operations |
 | Module compatibility profile (related to ISO/IEC 13211-2 and later WG17 amendment work) | module declarations, exports, imports, qualification, meta-predicate context | `modules/qualified_call`, `modules/selective_library_import`, `dcg_module_nonterminal_indicator` |
 | Part 3-oriented DCG compatibility profile | `-->`, terminal and partial sequences, grammar control constructs, semicontexts, nonterminal indicators, modules, `phrase/2-3`, steadfastness and errors | `dcg_terminals_and_remainder`, `dcg_control_constructs`, `dcg_partial_sequences`, `dcg_phrase_steadfastness`, `dcg_dynamic_nonterminal_indicator`, `logtalk_dcg_phrase_identity`, `logtalk_dcg_semicontexts`, DCG error and precedence cases |

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

@@ -0,0 +1,55 @@
+# ISO Part 1 processor-requirements audit
+
+This is the clause-level checklist for the processor requirements that sit
+above the individual built-ins. It complements `ISO-COMPLIANCE.md`: the latter
+is release-facing prose, while this file keeps each Clause 5 requirement or
+extension boundary visible as its own auditable row.
+
+The normative baseline is ISO/IEC 13211-1:1995 plus Technical Corrigenda 1-3.
+`covered` means the requirement has an implementation/documentation decision
+and executable evidence. `audit` means the implementation has relevant tests
+but the project has not yet reduced every dependent Clause 6-9 requirement to
+an explicit pass/not-applicable decision. No row here is an independent
+certification claim.
+
+## 5.1 — conforming processor obligations
+
+| 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(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 |
+
+## 5.2-5.4 — text, goals, and documentation
+
+| 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.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
+
+| Requirement | Status | EyeProlog decision / evidence |
+| --- | --- | --- |
+| 5.5 general extension rule | covered | normal mode may provide documented extensions; strict mode removes their Part 1 interpretation rather than changing implementation-defined choices |
+| 5.5.1 syntax extensions preserve standard token/text meaning | audit | WG17 syntax is a release gate and strict mode removes module/DCG/quad interpretation; a complete one-row preservation map for every Clause 6 production remains open |
+| 5.5.2 additional predefined operators | covered | strict mode starts from the Part 1 predefined operator table; normal-profile extra operators are documented and filtered |
+| 5.5.3 initial character-conversion mapping | covered | identity initial mapping; user changes are exercised through preparation/execution `char_conversion/2` behavior |
+| 5.5.4 additional term types | covered | the normal JavaScript API's `stringTerm(Text)` is documented as an implementation-specific sixth term type, including disjointness, ordering, clause conversion, lack of source token syntax, expression behavior, and writing; strict program/goal entry rejects that type with `representation_error(term)` |
+| 5.5.5 additional directives | covered | normal module/library directives are documented implementation-specific features and are rejected by strict mode |
+| 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.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 |
+
+## Exit-use rule
+
+A top-level row stays `audit` until all of the normative clauses it depends on
+have explicit pass, not-applicable, or documented implementation-defined
+outcomes. This prevents a large green regression suite from being mistaken for
+a completed processor-requirement audit.

package/test/conformance/README.md

@@ -9,7 +9,10 @@ The suite is intentionally file-based. Exact standard output, errors, warnings,
 and proof output test the behavior of the JavaScript implementation.
 [ISO-MATRIX.md](ISO-MATRIX.md) maps Part 1 normative clause families, all three
 corrigenda, plus EyeProlog's module and DCG compatibility profiles, to representative
-executable cases. [WG17-SYNTAX-STATUS.md](WG17-SYNTAX-STATUS.md) records the
+executable cases. [ISO-BUILTIN-MODE-ERROR-MATRIX.md](ISO-BUILTIN-MODE-ERROR-MATRIX.md)
+tracks the row-by-row built-in audit, while
+[ISO-PROCESSOR-REQUIREMENTS.md](ISO-PROCESSOR-REQUIREMENTS.md) decomposes the
+Clause 5 processor obligations. [WG17-SYNTAX-STATUS.md](WG17-SYNTAX-STATUS.md) records the
 complete one-to-one trace for the vendored active upstream WG17 syntax cases.
 [STC-DRAFT-STATUS.md](STC-DRAFT-STATUS.md) separately tracks executable
 implementation questions from the post-N289 working draft; those cases are
@@ -19,12 +22,11 @@ review evidence, not normative ISO claims.
 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
-processor-requirement ledger for the Part 1 strict-core audit. This suite is
+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. Selected prescribed-error sequences are now
-checked exactly (including term construction, database/all-solutions predicates,
-and ISO 8.14.1-8.14.4), while the remaining built-in error-order matrix is
-tracked in the compliance ledger. Cases under `iso/`
+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/`
 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

@@ -6,10 +6,12 @@ import {
   Program,
   Solver,
   Env,
+  compound,
   createStrictIsoRegistry,
   parseGoalText,
   parseProgramText,
   run,
+  stringTerm,
 } from '../src/index.js';
 import { TestReporter, isMainModule, runStandalone } from './test-style.mjs';
 
@@ -177,6 +179,23 @@ export function runIsoStrict(reporter = new TestReporter()) {
     equal(strict.stats.completed_goal_lists, 1, 'strict Unicode char_code/2');
   });
 
+  reporter.test('rejects the normal-profile string term extension at strict API boundaries', () => {
+    const normalSolver = new Solver(Program.parse(''), {});
+    const normalGoal = compound('=', [stringTerm('x'), stringTerm('x')]);
+    equal([...normalSolver.solve([normalGoal], new Env(), 0)].length, 1,
+      'normal API string terms remain usable');
+
+    const strictSolver = new Solver(Program.parse('', { isoStrict: true }), { isoStrict: true });
+    equal(capture(() => [...strictSolver.solve([normalGoal], new Env(), 0)]).formal,
+      'representation_error(term)', 'strict execution rejects API string terms');
+
+    equal(capture(() => new Program([{
+      head: compound('p', [stringTerm('x')]),
+      body: [],
+    }], { isoStrict: true })).formal,
+      'representation_error(term)', 'strict program construction rejects API string terms');
+  });
+
   reporter.test('keeps the strict write-option surface to Part 1 plus Corrigendum 3', () => {
     const strictError = capture(() => run('', {
       isoStrict: true,
@@ -608,6 +627,157 @@ export function runIsoStrict(reporter = new TestReporter()) {
       1, 'resource handling does not reintroduce a finite max_arity');
   });
 
+  reporter.test('converts asserted control bodies recursively per ISO 7.6.2', () => {
+    const source = ':- dynamic(p/0).\n:- dynamic(q/0).\n:- dynamic(r/0).\n';
+    const disjunction = run(source, {
+      isoStrict: true,
+      goal: 'assertz((p :- (X;true))), clause(p,B), arg(1,B,L), nonvar(L), functor(L,call,1)',
+    });
+    equal(disjunction.stats.completed_goal_lists, 1, 'variable in asserted disjunction becomes call/1');
+
+    const ifThenElse = run(source, {
+      isoStrict: true,
+      goal: 'assertz((q :- (X->Y;Z))), clause(q,B), arg(1,B,I), arg(1,I,XG), arg(2,I,YG), arg(2,B,ZG), nonvar(XG), nonvar(YG), nonvar(ZG), functor(XG,call,1), functor(YG,call,1), functor(ZG,call,1)',
+    });
+    equal(ifThenElse.stats.completed_goal_lists, 1, 'variables in asserted if-then-else become call/1');
+
+    const disjunctionError = capture(() => run(source, { isoStrict: true, goal: 'assertz((r :- (true;4)))' }));
+    equal(disjunctionError.formal, 'type_error(callable)', 'invalid asserted disjunction rejected during conversion');
+    includes(disjunctionError.message, "';'(true, 4)", 'asserted disjunction error identifies body');
+
+    const conjunctionError = capture(() => run(source, { isoStrict: true, goal: 'asserta((r :- (true,4)))' }));
+    equal(conjunctionError.formal, 'type_error(callable)', 'invalid asserted conjunction rejected during conversion');
+    includes(conjunctionError.message, '(true, 4)', 'asserted conjunction error identifies body');
+  });
+
+  reporter.test('closes the ISO 8.2-8.5 prescribed mode/error rows', () => {
+    const cases = [
+      ['compare(1,3,3.0)', 'type_error(atom)', 'compare/3 order type'],
+      ['compare(>=,3,3.0)', 'domain_error(order)', 'compare/3 order domain'],
+      ['sort([1|T],_)', 'instantiation_error', 'sort/2 partial input'],
+      ['sort(foo,_)', 'type_error(list)', 'sort/2 input list type'],
+      ['sort([],foo)', 'type_error(list)', 'sort/2 output list type'],
+      ['keysort([1-a|T],_)', 'instantiation_error', 'keysort/2 partial input'],
+      ['keysort(foo,_)', 'type_error(list)', 'keysort/2 input list type'],
+      ['keysort([],foo)', 'type_error(list)', 'keysort/2 output list type'],
+      ['keysort([X],_)', 'instantiation_error', 'keysort/2 variable pair'],
+      ['keysort([foo],_)', 'type_error(pair)', 'keysort/2 input pair type'],
+      ['keysort([],[foo])', 'type_error(pair)', 'keysort/2 output pair type'],
+      ['functor(X,Y,3)', 'instantiation_error', 'functor/3 Name instantiation'],
+      ['functor(X,foo,N)', 'instantiation_error', 'functor/3 Arity instantiation'],
+      ['functor(X,foo(a),a)', 'type_error(atomic)', 'functor/3 Name atomic type before Arity type'],
+      ['functor(X,foo,a)', 'type_error(integer)', 'functor/3 Arity integer type'],
+      ['functor(X,1.5,1)', 'type_error(atom)', 'functor/3 positive-arity atom name'],
+      ['functor(X,foo,-1)', 'domain_error(not_less_than_zero)', 'functor/3 non-negative arity'],
+      ['arg(X,foo(a),_)', 'instantiation_error', 'arg/3 index instantiation'],
+      ['arg(1,X,_)', 'instantiation_error', 'arg/3 term instantiation'],
+      ['arg(a,foo(a),_)', 'type_error(integer)', 'arg/3 index type'],
+      ['arg(0,atom,_)', 'type_error(compound)', 'arg/3 term type before index domain'],
+      ['arg(-1,foo(a),_)', 'domain_error(not_less_than_zero)', 'arg/3 index domain'],
+      ['X=..Y', 'instantiation_error', '=../2 both variables'],
+      ['X=..[foo|T]', 'instantiation_error', '=../2 partial list'],
+      ['X=..foo', 'type_error(list)', '=../2 list type'],
+      ['X=..[F,a]', 'instantiation_error', '=../2 head instantiation'],
+      ['X=..[3,a]', 'type_error(atom)', '=../2 compound functor atom type'],
+      ['X=..[foo(a)]', 'type_error(atomic)', '=../2 singleton atomic type'],
+      ['X=..[]', 'domain_error(non_empty_list)', '=../2 non-empty list'],
+      ['term_variables(t,[X|foo])', 'type_error(list)', 'term_variables/2 output list type'],
+    ];
+    for (const [goal, formal, label] of cases) {
+      equal(capture(() => run('', { isoStrict: true, goal })).formal, formal, label);
+    }
+
+    for (const goal of [
+      'unify_with_occurs_check(X,1)',
+      'subsumes_term(f(X,Y),f(Z,Z))',
+      'compare(<,a,b)',
+      'sort([1,1],[1])',
+      'keysort([2-b,1-a],[1-a,2-b])',
+      'copy_term(f(X,X),f(Y,Y))',
+      'term_variables(A+B+B,[A,B])',
+    ]) {
+      equal(run('', { isoStrict: true, goal }).stats.completed_goal_lists, 1, `${goal} mode`);
+    }
+  });
+
+  reporter.test('closes the ISO 8.15-8.17 prescribed mode/error rows', () => {
+    const cases = [
+      ['\\+(X)', 'instantiation_error', '\+/1 variable goal'],
+      ['\\+(3)', 'type_error(callable)', '\+/1 callable type'],
+      ['once(X)', 'instantiation_error', 'once/1 variable goal'],
+      ['once(3)', 'type_error(callable)', 'once/1 callable type'],
+      ['call(X,a)', 'instantiation_error', 'call/2 variable closure'],
+      ['call(3,a)', 'type_error(callable)', 'call/2 callable closure'],
+      ['call(foo,a,b,c,d,e,f,g,h)', 'existence_error(procedure)', 'selected call/N ceiling at call/8'],
+      ['atom_length(X,4)', 'instantiation_error', 'atom_length/2 atom instantiation'],
+      ['atom_length(1.2,4)', 'type_error(atom)', 'atom_length/2 atom type'],
+      ["atom_length(atom,'4')", 'type_error(integer)', 'atom_length/2 length type'],
+      ['atom_length(atom,-1)', 'domain_error(not_less_than_zero)', 'atom_length/2 length domain'],
+      ['atom_concat(X,small,Y)', 'instantiation_error', 'atom_concat/3 first/whole under-instantiation'],
+      ['atom_concat(small,X,Y)', 'instantiation_error', 'atom_concat/3 second/whole under-instantiation'],
+      ['atom_concat(1,a,b)', 'type_error(atom)', 'atom_concat/3 first type'],
+      ['atom_concat(a,1,b)', 'type_error(atom)', 'atom_concat/3 second type'],
+      ['atom_concat(a,b,1)', 'type_error(atom)', 'atom_concat/3 whole type'],
+      ['sub_atom(X,0,1,0,a)', 'instantiation_error', 'sub_atom/5 source instantiation'],
+      ['sub_atom(1,0,1,0,a)', 'type_error(atom)', 'sub_atom/5 source type'],
+      ['sub_atom(a,0,1,0,1)', 'type_error(atom)', 'sub_atom/5 result atom type'],
+      ['sub_atom(a,x,1,0,_)', 'type_error(integer)', 'sub_atom/5 Before type'],
+      ['sub_atom(a,0,x,0,_)', 'type_error(integer)', 'sub_atom/5 Length type'],
+      ['sub_atom(a,0,1,x,_)', 'type_error(integer)', 'sub_atom/5 After type'],
+      ['sub_atom(a,-1,1,0,_)', 'domain_error(not_less_than_zero)', 'sub_atom/5 Before domain'],
+      ['sub_atom(a,0,-1,0,_)', 'domain_error(not_less_than_zero)', 'sub_atom/5 Length domain'],
+      ['sub_atom(a,0,1,-1,_)', 'domain_error(not_less_than_zero)', 'sub_atom/5 After domain'],
+      ['atom_chars(X,Y)', 'instantiation_error', 'atom_chars/2 under-instantiation'],
+      ['atom_chars(1,[])', 'type_error(atom)', 'atom_chars/2 atom type'],
+      ['atom_chars(X,[a|foo])', 'type_error(list)', 'atom_chars/2 improper list'],
+      ['atom_chars(X,[Y,a])', 'instantiation_error', 'atom_chars/2 variable prefix element'],
+      ['atom_chars(X,[a,1])', 'type_error(character)', 'atom_chars/2 character element type'],
+      ['atom_codes(X,Y)', 'instantiation_error', 'atom_codes/2 under-instantiation'],
+      ['atom_codes(1,[])', 'type_error(atom)', 'atom_codes/2 atom type'],
+      ['atom_codes(X,[97|foo])', 'type_error(list)', 'atom_codes/2 improper list'],
+      ['atom_codes(X,[Y,97])', 'instantiation_error', 'atom_codes/2 variable prefix element'],
+      ['atom_codes(X,[97,foo])', 'type_error(integer)', 'atom_codes/2 code integer type'],
+      ['atom_codes(X,[97,-1])', 'representation_error(character_code)', 'atom_codes/2 code representation'],
+      ['char_code(X,Y)', 'instantiation_error', 'char_code/2 under-instantiation'],
+      ['char_code(ab,foo)', 'type_error(character)', 'char_code/2 character type before code type'],
+      ['char_code(a,foo)', 'type_error(integer)', 'char_code/2 code type'],
+      ['char_code(a,-1)', 'representation_error(character_code)', 'char_code/2 code representation'],
+      ['number_chars(X,Y)', 'instantiation_error', 'number_chars/2 under-instantiation'],
+      ['number_chars(foo,[])', 'type_error(number)', 'number_chars/2 number type'],
+      ['number_chars(X,[a|foo])', 'type_error(list)', 'number_chars/2 improper list'],
+      ['number_chars(X,[Y,a])', 'instantiation_error', 'number_chars/2 variable prefix element'],
+      ['number_chars(X,[a,1])', 'type_error(character)', 'number_chars/2 character element type'],
+      ['number_chars(X,[a])', 'syntax_error(number)', 'number_chars/2 number syntax'],
+      ['number_codes(X,Y)', 'instantiation_error', 'number_codes/2 under-instantiation'],
+      ['number_codes(foo,[])', 'type_error(number)', 'number_codes/2 number type'],
+      ['number_codes(X,[49|foo])', 'type_error(list)', 'number_codes/2 improper list'],
+      ['number_codes(X,[Y,49])', 'instantiation_error', 'number_codes/2 variable prefix element'],
+      ['number_codes(X,[49,foo])', 'type_error(integer)', 'number_codes/2 code integer type'],
+      ['number_codes(X,[49,-1])', 'representation_error(character_code)', 'number_codes/2 code representation'],
+      ['number_codes(X,[97])', 'syntax_error(number)', 'number_codes/2 number syntax'],
+      ['current_prolog_flag(1,_)', 'type_error(atom)', 'current_prolog_flag/2 flag type'],
+      ['current_prolog_flag(no_such_iso_flag,_)', 'domain_error(prolog_flag)', 'current_prolog_flag/2 flag domain'],
+      ['halt(X)', 'instantiation_error', 'halt/1 instantiation'],
+      ['halt(a)', 'type_error(integer)', 'halt/1 integer type'],
+    ];
+    for (const [goal, formal, label] of cases) {
+      equal(capture(() => run('', { isoStrict: true, goal })).formal, formal, label);
+    }
+
+    equal(run('', { isoStrict: true, goal: 'false' }).stats.completed_goal_lists, 0, 'false/0 fails');
+    const onceSolver = new Solver(Program.parse('', { isoStrict: true }), { isoStrict: true });
+    equal([...onceSolver.solve([parseGoalText('once((X=1;X=2))', { isoStrict: true })], new Env(), 0)].length,
+      1, 'once/1 first solution');
+    const onceCommittedSolver = new Solver(Program.parse('', { isoStrict: true }), { isoStrict: true });
+    equal([...onceCommittedSolver.solve([parseGoalText('once((X=1;X=2)), X=2', { isoStrict: true })], new Env(), 0)].length,
+      0, 'once/1 commits to its first solution');
+    const callSolver = new Solver(Program.parse('', { isoStrict: true }), { isoStrict: true });
+    equal([...callSolver.solve([parseGoalText('call(atom_concat,pro,log,prolog)', { isoStrict: true })], new Env(), 0)].length,
+      1, 'call/4 closure expansion');
+    equal(run('', { isoStrict: true, goal: 'atom_concat(A,B,ab)' }).stats.completed_goal_lists, 3, 'atom_concat/3 re-executable splits');
+    equal(run('', { isoStrict: true, goal: 'sub_atom(ab,_,_,_,_)' }).stats.completed_goal_lists, 6, 'sub_atom/5 re-executable slices');
+  });
+
   reporter.test('covers ISO database predicate errors and empty-procedure lifetime', () => {
     const errors = [
       ['current_predicate(4)', '', 'type_error(predicate_indicator)'],