eyeprolog 1.3.45 → 1.3.47

package/package.json

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

package/src/iso-limits.js

@@ -0,0 +1,8 @@
+// ISO/IEC 13211-1 implementation-defined processor limits.
+// Keep these values in one place so Prolog flags and all predicates that
+// expose representation limits cannot drift apart.
+
+// A finite arity limit keeps the Part 1 max_arity flag truthful. 65,535 is
+// comfortably representable by the JavaScript term model while giving source
+// parsing and term construction one stable ISO-visible boundary.
+export const ISO_MAX_ARITY = 65535;

package/src/iso.js

@@ -14,6 +14,7 @@ import { formatTermForWrite } from './write.js';
 import { emptyTerminalSequence, expandDcgBody, isListOrPartialList, validateDcgEmbeddedGoals } from './dcg.js';
 import { INVALID_UTF8_SENTINEL } from './io.js';
 import { CharacterRepresentationError, isStrictIsoPcsCharacter, isStrictIsoPcsCodePoint } from './iso-character.js';
+import { ISO_MAX_ARITY } from './iso-limits.js';
 import {
   characterCodeConstantEnd, continuesGraphicToken, isTerminatingFullStop, quotedEscapeEnd,
 } from './syntax-scan.js';
@@ -389,18 +390,26 @@ function* functorBuiltin({ goal, env }) {
     if (unify(goal.args[1], name, next) && unify(goal.args[2], numberTerm(term.arity), next)) yield next;
     return;
   }
+
   const name = deref(goal.args[1], env);
-  const arity = requireInteger(goal.args[2], env);
-  if (arity < 0n) throw new PrologError('domain_error(not_less_than_zero)', deref(goal.args[2], env));
-  if (arity > BigInt(Number.MAX_SAFE_INTEGER)) throw new PrologError('representation_error(max_arity)');
+  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,...).
+  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);
+  if (arityTerm.type !== NUMBER || !isDecimalInteger(arityTerm.name)) {
+    throw new PrologError('type_error(integer)', arityTerm);
+  }
+  const arity = BigInt(arityTerm.name);
+  if (arity > 0n && name.type !== ATOM) throw new PrologError('type_error(atom)', name);
+  if (arity > BigInt(ISO_MAX_ARITY)) throw new PrologError('representation_error(max_arity)');
+  if (arity < 0n) throw new PrologError('domain_error(not_less_than_zero)', arityTerm);
   if (arity === 0n) {
-    if (name.type === VAR) throw new PrologError('instantiation_error');
-    if (name.type === COMPOUND) throw new PrologError('type_error(atomic)', name);
     if (unify(goal.args[0], name, next)) yield next;
     return;
   }
-  if (name.type === VAR) throw new PrologError('instantiation_error');
-  if (name.type !== ATOM) throw new PrologError('type_error(atom)', name);
   const id = ++isoFresh;
   if (unify(goal.args[0], compound(name.name, Array.from({ length: Number(arity) }, (_, i) => variable(`__functor${id}_${i}`))), next)) yield next;
 }
@@ -420,6 +429,11 @@ function* univBuiltin({ goal, env }) {
   const term = deref(goal.args[0], env);
   const next = env.clone();
   if (term.type !== VAR) {
+    // 8.5.3.3(b) also applies in decomposition mode: a fixed second argument
+    // that is neither a list nor a partial list is an error, not failure.
+    if (listKind(goal.args[1], env) === 'nonlist') {
+      throw new PrologError('type_error(list)', deref(goal.args[1], env));
+    }
     const items = term.type === COMPOUND ? [atom(term.name), ...term.args] : [term];
     if (unify(goal.args[1], listFromItems(items), next)) yield next;
     return;
@@ -438,6 +452,7 @@ function* univBuiltin({ goal, env }) {
     return;
   }
   const name = requireAtom(items[0], env);
+  if (items.length - 1 > ISO_MAX_ARITY) throw new PrologError('representation_error(max_arity)');
   if (unify(goal.args[0], compound(name.name, items.slice(1)), next)) yield next;
 }
 
@@ -519,20 +534,15 @@ function* clauseBuiltin({ solver, goal, env }) {
   const head = deref(goal.args[0], env);
   if (head.type === VAR) throw new PrologError('instantiation_error');
   if (head.type !== ATOM && head.type !== COMPOUND) throw new PrologError('type_error(callable)', head);
-  callableOrVariable(goal.args[1], env);
   const indicator = compound('/', [atom(head.name), numberTerm(head.arity)]);
-  if (solver.registry.get(head.name, head.arity) || isGrammarRuleProcedure(solver, head)) {
-    throw new PrologError('permission_error(access, private_procedure)', indicator);
-  }
   const group = solver.program.findGroup(head.name, head.arity, head.module ?? goal.module ?? 'user');
-  if (!group) return;
-  // ISO 7.5.3 makes dynamic procedures public and static user-defined
-  // procedures private by default.  EyeProlog's normal profile keeps static
-  // clauses inspectable for proof tooling; strict core mode restores the ISO
-  // access rule used by clause/2.
-  if (solver.isoStrict && !group.dynamic) {
+  // ISO 8.8.1.3 places private-procedure access before Body callability.
+  if (solver.registry.get(head.name, head.arity) || isGrammarRuleProcedure(solver, head) ||
+      (solver.isoStrict && group && !group.dynamic)) {
     throw new PrologError('permission_error(access, private_procedure)', indicator);
   }
+  callableOrVariable(goal.args[1], env);
+  if (!group) return;
   for (const clause of group.clauses) {
     const pair = compound('$clause', [clause.head, clauseBodyTerm(clause.body)]);
     const copied = freshCopy(pair, new Env());
@@ -649,7 +659,7 @@ function predicateIndicatorParts(term, env) {
   if (name.type !== ATOM) throw new PrologError('type_error(atom)', name);
   const integer = BigInt(arity.name);
   if (integer < 0n) throw new PrologError('domain_error(not_less_than_zero)', arity);
-  if (integer > BigInt(Number.MAX_SAFE_INTEGER)) throw new PrologError('representation_error(max_arity)');
+  if (integer > BigInt(ISO_MAX_ARITY)) throw new PrologError('representation_error(max_arity)');
   return { name: name.name, arity: Number(integer), indicator };
 }
 
@@ -688,7 +698,8 @@ function* setPrologFlagBuiltin({ solver, goal, env }) {
   if (flag.type !== ATOM) throw new PrologError('type_error(atom)', flag);
   const definition = solver.prologFlags.get(flag.name);
   if (!definition) throw new PrologError('domain_error(prolog_flag)', flag);
-  if (value.type !== ATOM || !definition.allowed.includes(value.name)) {
+  const expectedType = definition.valueType ?? ATOM;
+  if (value.type !== expectedType || !definition.allowed.includes(value.name)) {
     throw new PrologError('domain_error(flag_value)', compound('+', [flag, value]));
   }
   if (!definition.changeable) throw new PrologError('permission_error(modify, flag)', flag);
@@ -1761,7 +1772,7 @@ function validCharacterCode(value, solver = null) {
 function listToAtomInput(list, env, kind, solver = null) {
   const { items, tail } = listElements(list, env);
   if (tail.type === VAR || items.some((item) => item.type === VAR)) throw new PrologError('instantiation_error');
-  if (tail.type !== ATOM || tail.name !== '[]') throw new PrologError('type_error(list)', tail);
+  if (tail.type !== ATOM || tail.name !== '[]') throw new PrologError('type_error(list)', list);
   if (kind === 'chars') {
     const invalid = items.find((item) => !oneChar(item));
     if (invalid) throw new PrologError('type_error(character)', invalid);
@@ -2072,11 +2083,13 @@ 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.
+  const invoked = callable(innerGoal, env);
   assertListOrPartial(bag, env);
   const collector = solver.cloneForInnerGoal(10000000);
   let compact = flatFindallTemplate(template);
   let collected = compact == null ? [] : null;
-  for (const answerEnv of collector.solve([callable(innerGoal, env)], env.clone(), 0)) {
+  for (const answerEnv of collector.solve([invoked], env.clone(), 0)) {
     if (compact != null && compact.push(template, answerEnv)) continue;
     if (compact != null) {
       collected = compact.materialize();
@@ -2135,8 +2148,9 @@ function sortedUnique(items) {
 
 function allSolutionsBuiltin(asSet) {
   return function* ({ solver, goal, env }) {
-    assertListOrPartial(goal.args[2], env);
+    // ISO 8.10.2.3/8.10.3.3 diagnose the iterated goal before Instances.
     const { iterated, quantified } = bagGoalParts(goal.args[1], env);
+    assertListOrPartial(goal.args[2], env);
     const free = freeVariables(iterated, goal.args[0], quantified, env);
     const collector = solver.cloneForInnerGoal(10000000);
     const groups = [];
@@ -2214,7 +2228,11 @@ function* callBuiltin({ solver, goal, env }) {
 function* callClosureBuiltin({ solver, goal, env }) {
   const closure = callable(goal.args[0], env);
   const existing = closure.type === COMPOUND ? closure.args : [];
-  const invoked = compound(closure.name, [...existing, ...goal.args.slice(1)]);
+  const extra = goal.args.slice(1);
+  if (existing.length + extra.length > ISO_MAX_ARITY) {
+    throw new PrologError('representation_error(max_arity)');
+  }
+  const invoked = compound(closure.name, [...existing, ...extra]);
   if (closure.module != null) invoked.module = closure.module;
   const child = solver.cloneForInnerGoal();
   try {

package/src/parser.js

@@ -3,6 +3,7 @@
 import { ATOM, COMPOUND, atom, compound, cons, emptyList, numberTerm, variable } from './term.js';
 import { continuesGraphicToken, isTerminatingFullStop } from './syntax-scan.js';
 import { CharacterRepresentationError, isStrictIsoPcsCodePoint } from './iso-character.js';
+import { ISO_MAX_ARITY } from './iso-limits.js';
 
 
 export class NumberRepresentationError extends Error {
@@ -723,6 +724,7 @@ class Parser {
     }
     while (true) {
       args.push(this.parseTerm(ARG_MIN_PRECEDENCE, false, false, true));
+      if (args.length > ISO_MAX_ARITY) throw new NumberRepresentationError('representation_error(max_arity)');
       if (this.token.type !== TOK.COMMA) break;
       this.advance();
     }

package/src/solver.js

@@ -13,6 +13,7 @@ import { StreamManager } from './io.js';
 import { clpzStateConsistent } from './clpz.js';
 import { hardHeapLimit, softHeapLimit, usedHeapSize } from './platform.js';
 import { evaluateWfs, relationForGroup, truthOfGroundGoal } from './wfs.js';
+import { ISO_MAX_ARITY } from './iso-limits.js';
 import { evaluatePositiveDatalog, relationForDatalogGroup, datalogCandidateIndexes } from './datalog.js';
 
 let freshCounter = 0;
@@ -961,7 +962,7 @@ function defaultPrologFlags(unknown = 'error', strictIso = false) {
     ['debug', { value: compound('off', []), allowed: ['on', 'off'], changeable: true }],
     ['max_integer', { value: null, allowed: [], changeable: false }],
     ['min_integer', { value: null, allowed: [], changeable: false }],
-    ['max_arity', { value: compound('unbounded', []), allowed: ['unbounded'], changeable: false }],
+    ['max_arity', { value: numberTerm(ISO_MAX_ARITY), allowed: [String(ISO_MAX_ARITY)], valueType: NUMBER, changeable: false }],
     ['unknown', { value: compound(unknown, []), allowed: ['error', 'fail', 'warning'], changeable: true }],
     ['double_quotes', { value: compound('chars', []), allowed: ['chars', 'codes', 'atom'], changeable: true }],
     ['occurs_check', { value: compound('true', []), allowed: ['true', 'error'], changeable: true }],

package/test/conformance/ISO-COMPLIANCE.md

@@ -31,9 +31,9 @@ error-ordering alternative to an individual executable assertion.
 | 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 strict ASCII 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 and PCS-based atom collation. |
+| 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 finite `max_arity` representation boundary used by term construction. |
 | 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. Public/private and multi-text requirements still need complete mapping. |
+| 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. 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.9 — expression evaluation | audit | Arithmetic/evaluation/error suites, including Corrigenda. Exceptional-value/error-precedence matrix remains to be exhaustively enumerated. |
@@ -69,6 +69,21 @@ normal profile retains Unicode scalar character data as an explicit extension.
 The complete WG17 syntax matrix remains green under this narrower strict
 boundary.
 
+
+The subsequent audit also reconciles the processor's arity limit: EyeProlog no
+longer advertises `max_arity=unbounded` while enforcing a hidden host ceiling.
+The implementation-defined Part 1 value is now `65535`, and the same boundary
+is used by parsing and the standard predicates whose error tables prescribe
+`representation_error(max_arity)`. Focused strict tests also lock the corrected
+8.5 term-construction errors, 8.8 clause-access precedence, 8.10 all-solutions
+goal/list precedence, database update errors, and Corrigendum 3 variable
+metadata traversal/write naming.
+
+The public WG17 `number_chars/2` comparison used in preparation of Corrigendum
+2 has additionally been checked against the current strict profile. That
+external comparison is useful independent evidence, but it is not yet vendored
+as an offline release gate; the exit criterion below therefore remains open.
+
 A further issue #65 audit closes the Part 1 flag family and tightens the 8.14
 term-I/O/operator error rules. The strict flag registry now distinguishes a
 standard value that is valid but not selectable from a value outside the
@@ -95,6 +110,15 @@ 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.
 
+The next Corrigendum 2 pass closes two smaller prescribed-error gaps.
+`call/2..8` now raises `representation_error(max_arity)` when appending its
+extra arguments would make the resulting goal exceed the declared `max_arity`,
+rather than falling through to a procedure-existence error. Reverse
+`atom_chars/2` and `atom_codes/2` now report the complete improper `List`
+argument as the culprit of `type_error(list, List)`, as required by the
+Corrigendum 2 replacement error clauses. Dedicated strict-core regressions pin
+both behaviors.
+
 ## Strict-core boundary
 
 `isoStrict: true` is intentionally a **Part 1 + Corrigenda 1-3** mode. It does

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

@@ -65,7 +65,7 @@ Status values are:
 | 9.1.3.1 | Integer division rounding function `rndI` | Truncation toward zero, matching the `integer_rounding_function=toward_zero` flag. | **defined** — BigInt division for `//` in `src/iso-arithmetic.js`. |
 | 7.11.2.1 | Whether preparation-time `Convc` affects execution-time `Convc` | Yes: mappings created while Prolog text is prepared are retained and initialize the solver's execution-time conversion map. | **defined** — `src/parser.js`, `src/program.js`, `src/solver.js`. |
 | 7.11.2.2 | Effect when `debug=on` | The flag is accepted and stored; it does not change goal semantics or enable a debugger. | **defined** — `src/solver.js`; no semantic branch depends on `debug`. |
-| 7.11.2.3 | Default `max_arity` | `unbounded` in the Prolog model, subject to host memory and practical JavaScript array/index limits. | **defined** — `src/solver.js`; relevant guards report representation/resource errors. |
+| 7.11.2.3 | Default `max_arity` | `65535`. The same finite limit is used by strict parsing and the standard predicates that prescribe `representation_error(max_arity)`. | **defined** — `src/iso-limits.js`, `src/solver.js`, `src/parser.js`, `src/iso.js`. |
 | 7.11.2.5 | Default `double_quotes` | `chars`. | **defined** — `src/solver.js`, parser flag state. |
 | 7.12.1 | Second argument of `error/2` | The default context term is the atom `eyeprolog`. A few implementation-specific diagnostics may deliberately supply a more specific context term. | **defined** — `formalErrorTerm()` in `src/iso.js`. |
 | 7.12.2(f) | Implementation-defined representation limits | Strict character and character-code operations are limited to the selected ASCII PCS/collating integers 0..127. Normal mode extends characters to Unicode scalar values. Arity/integer values are modeled as unbounded but may hit host/resource limits. Float input overflow uses the implementation-specific `max_float`/`min_float` representation names documented by the STC-oriented tests. | **defined** — parser/ISO numeric and character guards. |

package/test/conformance/ISO-MATRIX.md

@@ -11,12 +11,12 @@ 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, strict ASCII 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, including Corrigendum 2 `keysort/2` variable/non-pair errors |
+| 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 `functor/3` / `=../2` error-order plus max-arity checks |
 | 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` |
-| 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, and issue #65 checks for stream-term/property validation, text-vs-binary permissions, EOF/flush/position, and open/close semantics |
-| 8.15 logic and control | negation, once, repeat, `call/2` through `call/8`, `false/0` | `logtalk_once`, `corrigenda_call_closure`, `false_builtin` |
-| 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 |
+| 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 |
+| 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, and open/close semantics |
+| 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, and strict Corrigendum 2 improper-list culprit checks for `atom_chars/2` and `atom_codes/2` |
 | 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, and the strict complete-flag audit in `run-iso-strict.mjs` |
 | 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 and zero-arity unknown-evaluable error checks |
 | 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` |

package/test/conformance/README.md

@@ -22,8 +22,9 @@ target and the normal-mode module/DCG compatibility families. [ISO-COMPLIANCE.md
 processor-requirement 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 ISO 8.14.1-8.14.4), while the remaining built-in
-error-order matrix is tracked in the compliance ledger. Cases under `iso/`
+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/`
 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/conformance/expected/iso/exceptions_and_flags.pl

@@ -1,3 +1,3 @@
 answer(7, red, caught(eyeprolog), first, caught(eyeprolog)).
 answer(7, red, caught(eyeprolog), second, caught(eyeprolog)).
-flags(off, on, [pair(bounded, false), pair(integer_rounding_function, toward_zero), pair(char_conversion, on), pair(debug, off), pair(max_arity, unbounded), pair(unknown, fail), pair(double_quotes, chars), pair(occurs_check, true)]).
+flags(off, on, [pair(bounded, false), pair(integer_rounding_function, toward_zero), pair(char_conversion, on), pair(debug, off), pair(max_arity, 65535), pair(unknown, fail), pair(double_quotes, chars), pair(occurs_check, true)]).

package/test/conformance/expected-errors/iso/logtalk_functor_compound_name.txt

@@ -1 +1 @@
-error(type_error(atom), foo(a))
+error(type_error(atomic), foo(a))

package/test/run-iso-strict.mjs

@@ -55,7 +55,7 @@ export function runIsoStrict(reporter = new TestReporter()) {
       'current_prolog_flag(integer_rounding_function,toward_zero)',
       'current_prolog_flag(char_conversion,on)',
       'current_prolog_flag(debug,off)',
-      'current_prolog_flag(max_arity,unbounded)',
+      'current_prolog_flag(max_arity,65535)',
       'current_prolog_flag(unknown,error)',
       'current_prolog_flag(double_quotes,chars)',
     ]) equal(answers(goalText), 1, goalText);
@@ -71,8 +71,8 @@ export function runIsoStrict(reporter = new TestReporter()) {
       'permission_error(modify, flag)', 'bounded valid-but-fixed value');
     equal(capture(() => run('', { isoStrict: true, goal: 'set_prolog_flag(integer_rounding_function,down)' })).formal,
       'permission_error(modify, flag)', 'rounding valid-but-fixed value');
-    equal(capture(() => run('', { isoStrict: true, goal: 'set_prolog_flag(max_arity,unbounded)' })).formal,
-      'permission_error(modify, flag)', 'max_arity fixed value');
+    equal(capture(() => run('', { isoStrict: true, goal: 'set_prolog_flag(max_arity,65535)' })).formal,
+      'permission_error(modify, flag)', 'max_arity valid-but-fixed value');
     equal(capture(() => run('', { isoStrict: true, goal: 'set_prolog_flag(max_integer,unbounded)' })).formal,
       'domain_error(flag_value)', 'max_integer has no value when unbounded');
     equal(capture(() => run('', { isoStrict: true, goal: 'set_prolog_flag(unknown,maybe)' })).formal,
@@ -81,6 +81,15 @@ export function runIsoStrict(reporter = new TestReporter()) {
       'domain_error(prolog_flag)', 'unsupported flag');
   });
 
+  reporter.test('keeps max_arity consistent with term and predicate-indicator limits', () => {
+    equal(capture(() => run('', { isoStrict: true, goal: 'functor(_,foo,65536)' })).formal,
+      'representation_error(max_arity)', 'functor/3 arity boundary');
+    equal(capture(() => run('', { isoStrict: true, goal: 'abolish(foo/65536)' })).formal,
+      'representation_error(max_arity)', 'abolish/1 arity boundary');
+    equal(capture(() => run('', { isoStrict: true, goal: 'set_prolog_flag(max_arity,unbounded)' })).formal,
+      'domain_error(flag_value)', 'unbounded is not the selected max_arity value');
+  });
+
   reporter.test('preparation-time char_conversion affects later unquoted source only', () => {
     const program = Program.parse(
       ":- char_conversion(x,y).\np(x).\nquoted('x').\n:- set_prolog_flag(char_conversion,off).\nraw(x).\n",
@@ -153,6 +162,27 @@ export function runIsoStrict(reporter = new TestReporter()) {
     includes(normal.stdout, '"ab"', 'normal-profile extension remains available');
   });
 
+  reporter.test('follows Corrigendum 3 variable metadata traversal and write naming', () => {
+    const readMetadata = run('', {
+      isoStrict: true,
+      goal: "read_term(f(B,A,B,C,D,E),[variables([B,A,C,D,E]),variable_names(['B'=B,'A'=A,'C'=C,'_D'=D]),singletons(['A'=A,'C'=C,'_D'=D])])",
+      ioOptions: { input: 'f(B,A,B,C,_D,_).' },
+    });
+    equal(readMetadata.stats.completed_goal_lists, 1, 'read metadata order');
+
+    const named = run('', {
+      isoStrict: true,
+      goal: "write_term(f(X,Y,X),[quoted(true),variable_names([z=X,a=X,y=Y])])",
+    });
+    includes(named.stdout, 'f(z,y,z)', 'leftmost variable name wins');
+
+    const ignoredNonVariable = run('', {
+      isoStrict: true,
+      goal: "write_term(X,[variable_names([ignored=42,x=X])])",
+    });
+    includes(ignoredNonVariable.stdout, 'x', 'non-variable right side is permitted and ignored');
+  });
+
   reporter.test('follows the ISO 8.14.1.3 read_term/3 error order', () => {
     equal(capture(() => run('', { isoStrict: true, goal: 'read_term(f(a),_,[X])' })).formal,
       'instantiation_error', 'partial/variable option before stream domain');
@@ -213,6 +243,45 @@ export function runIsoStrict(reporter = new TestReporter()) {
       'type_error(atom)', 'operator type');
   });
 
+  reporter.test('follows ISO term-construction error types and precedence', () => {
+    equal(capture(() => run('', { isoStrict: true, goal: 'functor(_,foo(a),1)' })).formal,
+      'type_error(atomic)', 'functor compound name');
+    equal(capture(() => run('', { isoStrict: true, goal: 'functor(_,foo(a),bad)' })).formal,
+      'type_error(atomic)', 'functor name error before arity type');
+    equal(capture(() => run('', { isoStrict: true, goal: "'=..'(foo,bar)" })).formal,
+      'type_error(list)', '=../2 fixed non-list');
+  });
+
+  reporter.test('enforces Corrigendum 2 call/N max-arity errors', () => {
+    equal(capture(() => run('', {
+      isoStrict: true,
+      goal: 'functor(T,f,65535), call(T,x)',
+    })).formal, 'representation_error(max_arity)', 'call/2 resulting arity');
+  });
+
+  reporter.test('reports the complete List culprit for Corrigendum 2 atomic conversions', () => {
+    for (const goal of ['atom_chars(A,[a|foo])', 'atom_codes(A,[97|foo])']) {
+      const error = capture(() => run('', { isoStrict: true, goal }));
+      equal(error.formal, 'type_error(list)', `${goal} formal`);
+      includes(error.message, '[', `${goal} complete list culprit`);
+      if (error.message.endsWith(', foo)')) throw new Error(`${goal}: reported only the improper tail`);
+    }
+  });
+
+  reporter.test('follows ISO clause/2 private-procedure error precedence', () => {
+    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', () => {
+    for (const predicate of ['findall', 'bagof', 'setof']) {
+      equal(capture(() => run('', { isoStrict: true, goal: `${predicate}(X,Y,foo)` })).formal,
+        'instantiation_error', `${predicate}/3 variable goal`);
+      equal(capture(() => run('', { isoStrict: true, goal: `${predicate}(X,4,foo)` })).formal,
+        'type_error(callable)', `${predicate}/3 non-callable goal`);
+    }
+  });
+
   reporter.test('uses the Part 1 predefined operator table', () => {
     const program = Program.parse('', { isoStrict: true });
     equal(program.operators.has('fx\u0000?-'), true, 'fx ?-');
@@ -253,6 +322,47 @@ export function runIsoStrict(reporter = new TestReporter()) {
     equal(answers.length, 1, 'answer count');
   });
 
+  reporter.test('covers ISO database predicate errors and empty-procedure lifetime', () => {
+    const errors = [
+      ['current_predicate(4)', '', 'type_error(predicate_indicator)'],
+      ['asserta(_)', '', 'instantiation_error'],
+      ['asserta(4)', '', 'type_error(callable)'],
+      ['asserta((atom(_):-true))', '', 'permission_error(modify, static_procedure)'],
+      ['assertz(_)', '', 'instantiation_error'],
+      ['assertz(4)', '', 'type_error(callable)'],
+      ['retract(_)', '', 'instantiation_error'],
+      ['retract(4)', '', 'type_error(callable)'],
+      ['retract(atom(_))', '', 'permission_error(modify, static_procedure)'],
+      ['retractall(_)', '', 'instantiation_error'],
+      ['retractall(3)', '', 'type_error(callable)'],
+      ['retractall(retractall(_))', '', 'permission_error(modify, static_procedure)'],
+      ['abolish(foo/_)', '', 'instantiation_error'],
+      ['abolish(foo)', '', 'type_error(predicate_indicator)'],
+      ['abolish(foo/a)', '', 'type_error(integer)'],
+      ['abolish(4/1)', '', 'type_error(atom)'],
+      ['abolish(foo/(-1))', '', 'domain_error(not_less_than_zero)'],
+      ['abolish(atom/1)', '', 'permission_error(modify, static_procedure)'],
+    ];
+    for (const [goal, source, formal] of errors) {
+      equal(capture(() => run(source, { isoStrict: true, goal })).formal, formal, goal);
+    }
+
+    const retained = run(':- dynamic(p/1).\np(a).\n', {
+      isoStrict: true,
+      goal: 'retractall(p(_)), current_predicate(p/1), \\+ clause(p(_),_)',
+    });
+    equal(retained.stats.completed_goal_lists, 1, 'retractall keeps the dynamic procedure');
+
+    const empty = run(':- dynamic(empty/1).\n', { isoStrict: true, goal: 'current_predicate(empty/1)' });
+    equal(empty.stats.completed_goal_lists, 1, 'declared empty procedure exists');
+
+    const abolished = run(':- dynamic(q/1).\nq(a).\n', {
+      isoStrict: true,
+      goal: 'abolish(q/1), \\+ current_predicate(q/1)',
+    });
+    equal(abolished.stats.completed_goal_lists, 1, 'abolish removes the procedure');
+  });
+
   reporter.test('disables automatic tabling and recursion guards', () => {
     const group = Program.parse('p :- p.\n', { isoStrict: true }).findGroup('p', 0);
     equal(group?.recursive, false, 'recursive planner');

package/the-art-of-eyeprolog.md

@@ -6004,7 +6004,7 @@ silently changing a static program.
 | `debug` | `off` | `on`, `off` | yes |
 | `max_integer` | no current value because `bounded=false` | not applicable | no |
 | `min_integer` | no current value because `bounded=false` | not applicable | no |
-| `max_arity` | `unbounded` | `unbounded` | no |
+| `max_arity` | `65535` | `65535` | no |
 | `unknown` | `error` | `error`, `fail`, `warning` | yes |
 | `double_quotes` | `chars` | `chars`, `codes`, `atom` | yes |
 | `occurs_check` | `true` | `true`, `error` | yes |