eyeprolog 1.3.51 → 1.3.53

package/package.json

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

package/src/iso-arithmetic.js

@@ -5,6 +5,19 @@ import {
 } from './term.js';
 import { PrologError } from './errors.js';
 
+function integerResource(operation) {
+  try {
+    return operation();
+  } catch (error) {
+    // With bounded=false, integer operations have no language-level numeric
+    // representation bound.  A finite host can nevertheless exhaust storage
+    // (V8 reports oversized BigInt powers/shifts as RangeError).  Keep that
+    // implementation resource boundary inside the ISO error model.
+    if (error?.name === 'RangeError') throw new PrologError('resource_error(memory)');
+    throw error;
+  }
+}
+
 function evaluate(term, env, options = {}) {
   term = deref(term, env);
   if (term.type === VAR) throw new PrologError('instantiation_error');
@@ -91,9 +104,17 @@ function evaluateOperation(term, args, options = {}) {
     if (options.isoStrict === true && ['truncate', 'round', 'ceiling', 'floor'].includes(name) && args[0].integer) {
       throw new PrologError('type_error(float)', numericTerm(args[0]));
     }
-    const a = Number(args[0].value);
     if (name === 'abs' && args[0].integer) return { integer: true, value: args[0].value < 0n ? -args[0].value : args[0].value };
     if (name === 'sign' && args[0].integer) return { integer: true, value: args[0].value < 0n ? -1n : args[0].value > 0n ? 1n : 0n };
+    const a = Number(args[0].value);
+    // The int-exp -> float templates first apply the processor's I->F
+    // conversion. With unbounded integers that conversion can overflow even
+    // though the integer itself is representable. Do not let a host math
+    // function observe +/-Infinity and turn the required float-overflow into
+    // a different result (for example atan(Huge) = pi/2).
+    if (options.isoStrict === true && args[0].integer && !Number.isFinite(a)) {
+      throw new PrologError('evaluation_error(float_overflow)');
+    }
     if (name === 'truncate' || name === 'round' || name === 'ceiling' || name === 'floor') {
       const fn = name === 'truncate' ? Math.trunc : name === 'round' ? Math.round : name === 'ceiling' ? Math.ceil : Math.floor;
       return { integer: true, value: BigInt(fn(a)) };
@@ -107,6 +128,13 @@ function evaluateOperation(term, args, options = {}) {
     const value = fn(a);
     if (Number.isNaN(value) || (name === 'log' && a === 0)) throw new PrologError('evaluation_error(undefined)');
     if (!Number.isFinite(value)) throw new PrologError('evaluation_error(float_overflow)');
+    // Unlike the implementation-defined resultF choice for ordinary floating
+    // arithmetic, exp/1 has an explicit exceptional condition when its
+    // mathematical non-zero result is too small to represent. Math.exp()
+    // signals that boundary by rounding the positive result to zero.
+    if (options.isoStrict === true && name === 'exp' && value === 0) {
+      throw new PrologError('evaluation_error(underflow)');
+    }
     return { integer: false, value };
   }
   if (arity !== 2) throw new PrologError('type_error(evaluable)', compound('/', [atom(name), numberTerm(arity)]));
@@ -117,7 +145,7 @@ function evaluateOperation(term, args, options = {}) {
     throw new PrologError('type_error(integer)', numericTerm(invalid));
   }
   if (bothInteger && name === '^') {
-    if (b >= 0n) return { integer: true, value: a ** b };
+    if (b >= 0n) return { integer: true, value: integerResource(() => a ** b) };
     if (a === 0n) throw new PrologError('evaluation_error(undefined)');
     if (a === 1n) return { integer: true, value: 1n };
     if (a === -1n) return { integer: true, value: (-b) % 2n === 0n ? 1n : -1n };
@@ -126,23 +154,47 @@ function evaluateOperation(term, args, options = {}) {
   }
   if (bothInteger && ['+', '-', '*', '//', 'div', 'mod', 'rem', '/\\', '\\/', 'xor', '<<', '>>'].includes(name)) {
     if ((name === '//' || name === 'div' || name === 'mod' || name === 'rem') && b === 0n) throw new PrologError('evaluation_error(zero_divisor)');
-    if (name === '+') return { integer: true, value: a + b };
-    if (name === '-') return { integer: true, value: a - b };
-    if (name === '*') return { integer: true, value: a * b };
-    if (name === '//') return { integer: true, value: a / b };
+    if (name === '+') return { integer: true, value: integerResource(() => a + b) };
+    if (name === '-') return { integer: true, value: integerResource(() => a - b) };
+    if (name === '*') return { integer: true, value: integerResource(() => a * b) };
+    if (name === '//') return { integer: true, value: integerResource(() => a / b) };
     if (name === 'div') {
-      const quotient = a / b;
-      const remainder = a % b;
-      return { integer: true, value: remainder !== 0n && ((a < 0n) !== (b < 0n)) ? quotient - 1n : quotient };
+      return { integer: true, value: integerResource(() => {
+        const quotient = a / b;
+        const remainder = a % b;
+        return remainder !== 0n && ((a < 0n) !== (b < 0n)) ? quotient - 1n : quotient;
+      }) };
     }
-    if (name === 'rem') return { integer: true, value: a % b };
-    if (name === 'mod') return { integer: true, value: ((a % b) + b) % b };
-    if (name === '/\\') return { integer: true, value: a & b };
-    if (name === '\\/') return { integer: true, value: a | b };
-    if (name === 'xor') return { integer: true, value: a ^ b };
-    if (name === '<<') return { integer: true, value: a << b };
-    if (name === '>>') return { integer: true, value: a >> b };
+    if (name === 'rem') return { integer: true, value: integerResource(() => a % b) };
+    if (name === 'mod') return { integer: true, value: integerResource(() => ((a % b) + b) % b) };
+    if (name === '/\\') return { integer: true, value: integerResource(() => a & b) };
+    if (name === '\\/') return { integer: true, value: integerResource(() => a | b) };
+    if (name === 'xor') return { integer: true, value: integerResource(() => a ^ b) };
+    if (name === '<<') return { integer: true, value: integerResource(() => a << b) };
+    if (name === '>>') return { integer: true, value: integerResource(() => a >> b) };
+  }
+  // Power has prescribed exceptional conditions that depend on the evaluated
+  // operand values/types and therefore precede any I->F conversion needed by
+  // the selected floating template. Checking these first matters with
+  // unbounded integers: conversion overflow must not hide an already-satisfied
+  // undefined-power condition.
+  const aNegative = args[0].integer ? a < 0n : a < 0;
+  const aZero = args[0].integer ? a === 0n : a === 0;
+  const bNegative = args[1].integer ? b < 0n : b < 0;
+  if (options.isoStrict === true && name === '**' && aNegative && !args[1].integer) {
+    // Corrigendum 3 corrects the operand name in 9.3.1.3(c): **/2 requires
+    // an integer-typed exponent for a negative base. A float such as 2.0 is
+    // still not an integer value of the required type here.
+    throw new PrologError('evaluation_error(undefined)');
   }
+  if (options.isoStrict === true && name === '^' && aNegative && !args[1].integer && !Number.isInteger(b)) {
+    // Corrigendum 2 ^/2 additionally accepts a float with an integer value.
+    throw new PrologError('evaluation_error(undefined)');
+  }
+  if ((name === '**' || name === '^') && aZero && bNegative) {
+    throw new PrologError('evaluation_error(undefined)');
+  }
+
   const x = Number(a), y = Number(b);
   if ((!Number.isFinite(x) || !Number.isFinite(y)) && name !== 'max' && name !== 'min') {
     throw new PrologError('evaluation_error(float_overflow)');
@@ -158,11 +210,6 @@ function evaluateOperation(term, args, options = {}) {
     if (x === 0 && y === 0) throw new PrologError('evaluation_error(undefined)');
     value = Math.atan2(x, y);
   }
-  else if ((name === '**' || name === '^') && x === 0 && y < 0) {
-    // 9.3.1.3(d) and Cor.2 9.3.10.3(d): zero to a negative power is
-    // undefined, not floating-point overflow.
-    throw new PrologError('evaluation_error(undefined)');
-  }
   else if (name === '+') value = x + y;
   else if (name === '-') value = x - y;
   else if (name === '*') value = x * y;
@@ -171,6 +218,14 @@ function evaluateOperation(term, args, options = {}) {
   else throw new PrologError('type_error(evaluable)', compound('/', [atom(name), numberTerm(arity)]));
   if (Number.isNaN(value)) throw new PrologError('evaluation_error(undefined)');
   if (!Number.isFinite(value)) throw new PrologError('evaluation_error(float_overflow)');
+  // Part 1 **/2 and Corrigendum 2 ^/2 prescribe underflow when a
+  // mathematically non-zero floating power is too small. A non-zero finite
+  // base cannot have an exact zero power result, so a host result of +/-0 is
+  // the observable underflow boundary. Zero raised to a positive power remains
+  // the ordinary exact zero case.
+  if (options.isoStrict === true && (name === '**' || name === '^') && value === 0 && x !== 0) {
+    throw new PrologError('evaluation_error(underflow)');
+  }
   return { integer: false, value };
 }
 export function arithmeticValueTerm(value) {

package/src/iso-limits.js

@@ -1,8 +1,7 @@
 // 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;
+//
+// max_arity describes the maximum arity of *compound terms*, not a separate
+// implementation limit on procedures. EyeProlog does not impose a fixed
+// compound-term arity ceiling: practical exhaustion is a resource issue.
+// Keep null as the internal sentinel for the standard flag value `unbounded`.
+export const ISO_MAX_ARITY = null;

package/src/iso.js

@@ -404,14 +404,30 @@ function* functorBuiltin({ goal, env }) {
   }
   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 (ISO_MAX_ARITY != null && 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 (unify(goal.args[0], name, next)) yield next;
     return;
   }
+  // `max_arity = unbounded` means there is no ISO-visible representation
+  // ceiling on compound terms.  The JavaScript host still has finite storage
+  // resources, however.  In particular an Array length is limited to 2^32-1
+  // and allocation can fail before that.  Report host exhaustion as the ISO
+  // resource error family rather than leaking a JavaScript RangeError or
+  // reintroducing an artificial max_arity limit.
+  if (arity > 0xffffffffn) throw new PrologError('resource_error(memory)');
   const id = ++isoFresh;
-  if (unify(goal.args[0], compound(name.name, Array.from({ length: Number(arity) }, (_, i) => variable(`__functor${id}_${i}`))), next)) yield next;
+  let args;
+  try {
+    args = Array.from({ length: Number(arity) }, (_, i) => variable(`__functor${id}_${i}`));
+  } catch (error) {
+    if (error?.name === 'RangeError') throw new PrologError('resource_error(memory)');
+    throw error;
+  }
+  if (unify(goal.args[0], compound(name.name, args), next)) yield next;
 }
 
 function* argBuiltin({ goal, env }) {
@@ -460,7 +476,9 @@ 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 (ISO_MAX_ARITY != null && 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;
 }
 
@@ -591,12 +609,17 @@ function isGrammarRuleProcedure(solver, head) {
 
 function isProcessorStaticProcedure(solver, head) {
   // Conjunction is an ISO control construct (7.5/Table 9) but is executed
-  // directly by the solver rather than through the builtin registry.  Keep it
-  // in the same protected static/private family as the registered Part 1
-  // control constructs for runtime database operations.
+  // directly by the solver rather than through the builtin registry.  The
+  // source syntax functors (:-)/1-2 likewise have processor-defined roles and
+  // STC #56 calls for protecting them from database modification. Keep these
+  // in the same static/private family for strict runtime database operations.
+  const strictSyntaxProcedure = solver.isoStrict && (
+    (head.name === ',' && head.arity === 2) ||
+    (head.name === ':-' && (head.arity === 1 || head.arity === 2))
+  );
   return Boolean(solver.registry.get(head.name, head.arity)) ||
     isGrammarRuleProcedure(solver, head) ||
-    (solver.isoStrict && head.name === ',' && head.arity === 2);
+    strictSyntaxProcedure;
 }
 
 function assertModifiable(solver, head, module = 'user') {
@@ -677,8 +700,14 @@ 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(ISO_MAX_ARITY)) throw new PrologError('representation_error(max_arity)');
-  return { name: name.name, arity: Number(integer), indicator };
+  if (ISO_MAX_ARITY != null && integer > BigInt(ISO_MAX_ARITY)) {
+    throw new PrologError('representation_error(max_arity)');
+  }
+  // Actual clause arities are ordinary JavaScript array lengths. For a very
+  // large predicate indicator that names no existing procedure, retain the
+  // exact integer in the map key instead of rounding it through Number.
+  const runtimeArity = integer <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(integer) : integer;
+  return { name: name.name, arity: runtimeArity, indicator };
 }
 
 function* abolishBuiltin({ solver, goal, env }) {
@@ -2279,7 +2308,7 @@ function* callClosureBuiltin({ solver, goal, env }) {
   const closure = callable(goal.args[0], env);
   const existing = closure.type === COMPOUND ? closure.args : [];
   const extra = goal.args.slice(1);
-  if (existing.length + extra.length > ISO_MAX_ARITY) {
+  if (ISO_MAX_ARITY != null && existing.length + extra.length > ISO_MAX_ARITY) {
     throw new PrologError('representation_error(max_arity)');
   }
   const invoked = compound(closure.name, [...existing, ...extra]);

package/src/parser.js

@@ -724,7 +724,9 @@ 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 (ISO_MAX_ARITY != null && args.length > ISO_MAX_ARITY) {
+        throw new NumberRepresentationError('representation_error(max_arity)');
+      }
       if (this.token.type !== TOK.COMMA) break;
       this.advance();
     }

package/src/program.js

@@ -1317,8 +1317,13 @@ function assertPredicateIsDefinable(name, arity, strictIso = false) {
   // be redefined in either profile.  Strict core mode extends the same ISO
   // rule to every Part-1 built-in/control construct; the normal EyeProlog
   // profile keeps its historical source-compatibility behavior.
+  const strictSyntaxProcedure = strictIso && (
+    (name === ',' && arity === 2) ||
+    (name === ':-' && (arity === 1 || arity === 2))
+  );
   if ((name === 'false' && arity === 0) ||
-      (strictIso && (getStrictIsoRegistry().get(name, arity) || (name === ',' && arity === 2)))) {
+      (strictIso && getStrictIsoRegistry().get(name, arity)) ||
+      strictSyntaxProcedure) {
     throw staticProcedureModificationError(name, arity);
   }
 }

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 {
-  COMPOUND, NUMBER, VAR, Env, compactListLength, compactVariableList, compound, cons, copyResolved, deref, emptyList,
+  ATOM, COMPOUND, NUMBER, VAR, Env, compactListLength, compactVariableList, compound, cons, copyResolved, deref, emptyList,
   flattenConjunction, freshTerm, isCons, isDecimalInteger, isEmptyList,
   numberTerm, numberTextFromDouble, termIsGround, termToString, unify, variable, variantTerms,
 } from './term.js';
@@ -962,7 +962,9 @@ 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: numberTerm(ISO_MAX_ARITY), allowed: [String(ISO_MAX_ARITY)], valueType: NUMBER, changeable: false }],
+    ['max_arity', ISO_MAX_ARITY == null
+      ? { value: compound('unbounded', []), allowed: ['unbounded'], valueType: ATOM, changeable: false }
+      : { 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,17 +31,17 @@ 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, PCS-based atom collation, and the finite `max_arity` representation boundary used by term construction. |
+| 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.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, including runtime protection of the solver-native conjunction control construct `','/2`. 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 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.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. Strict mode now also pins direct-variable precedence, arithmetic operand type errors, float-only rounding conversions, zero-to-negative-power undefined errors, and the Part 1 mixed integer/float comparison conversion rule. Exceptional-value/error-precedence mapping remains to be exhaustively enumerated. |
+| 7.9 — expression evaluation | audit | Arithmetic/evaluation/error suites, including Corrigenda. Strict mode now pins direct-variable precedence, arithmetic operand 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 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. Strict mode excludes the EyeProlog `occurs_check` extension. |
-| 7.12 — errors | audit | ISO `error(Error, Context)` envelope, type/domain/permission/representation/evaluation/syntax 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, and arithmetic culprit/precedence reporting. 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, and additional prescribed precedence for `arg/3`, `atom_concat/3`, `sub_atom/5`, number/atom list conversions, and `char_conversion/2`. The remaining mode/error matrix is not yet one-row-per-standard-row. |
-| 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, enforces the Part 1 numeric/integer operand errors and float-only rounding modes, and uses the Part 1 integer-to-float conversion rule for mixed arithmetic comparisons. Normal mode retains EyeProlog's exact mixed-type comparison extension. Host floating-point representation choices remain documented implementation-defined behavior; exhaustive exceptional-value precedence remains open. |
+| 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, 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. The remaining mode/error matrix is not yet one-row-per-standard-row. |
+| 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, enforces the Part 1 numeric/integer operand errors and 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. |
 | Corrigendum 3 | covered | Writer options, `variable_names/1`, canonical list output and negative-power corrections have dedicated cases. |
@@ -70,14 +70,17 @@ 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 subsequent arity audit originally selected a finite `max_arity=65535`, but
+issue #66 and the post-Corrigendum STC review exposed that as the wrong
+abstraction: Part 1 `max_arity` is the maximum arity of **compound terms**, not
+a procedure-arity limit. EyeProlog now again selects `max_arity=unbounded` and
+removes the artificial 65535 checks from source parsing, `functor/3`, `=../2`,
+predicate indicators, and Corrigendum 2 `call/N` closure expansion. Practical
+host exhaustion remains a resource condition rather than a declared term-arity
+boundary. Focused strict tests also lock the corrected 8.5 term-construction
+errors, 8.8 clause-access precedence, 8.10 all-solutions goal/list precedence,
+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
@@ -110,14 +113,13 @@ 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.
+The next Corrigendum 2 pass closed the prescribed `call/2..8` max-arity
+branch for processors with a finite `max_arity`, and corrected reverse
+`atom_chars/2` / `atom_codes/2` improper-list culprits. After issue #66 restored
+EyeProlog's selected `max_arity=unbounded`, the conditional `call/N`
+`representation_error(max_arity)` branch is intentionally unreachable unless a
+future processor profile selects a finite compound-term limit; closure
+expansion itself remains covered by strict regressions.
 
 
 The following Part 1 pass tightens more of the still-open prescribed-error and
@@ -135,6 +137,43 @@ its exact cross-type comparison as an extension. Dedicated strict regressions
 cover these distinctions without changing the normal-profile arithmetic error
 contract.
 
+A further Clause 9 pass closes the floating conversion and exceptional-value
+boundary exposed by unbounded integers. Strict floating evaluable functors now
+perform the required integer-to-float conversion before invoking the host math
+operation, so an integer outside the selected finite binary64 range reports
+`evaluation_error(float_overflow)` rather than producing a secondary host-math
+result. The explicit underflow clauses for `exp/1`, Part 1 `**/2`, and
+Corrigendum 2 `^/2` are enforced even though EyeProlog retains the
+implementation-defined `round(x)` choice for generic `resultF` arithmetic. The
+power audit also preserves the specified negative-base and zero/negative
+exception conditions before any later I->F overflow, including Corrigendum 3's
+correction to the `**/2` operand wording and Corrigendum 2's distinct rule that
+`^/2` may accept an integer-valued float exponent.
+
+## Post-Corrigendum STC cross-check
+
+The public WG17 STC draft is tracked as useful defect-discovery material, but it
+is not silently treated as a fourth published Corrigendum. The current audit
+confirms EyeProlog already has the behavior implicated by the substantive STC
+items on negative-number layout/operator syntax, arithmetic instantiation
+precedence, EOF actions/end tokens, character/code/byte output error overlap,
+clause head/body variable identity, sequential `op/3` and `set_prolog_flag/2`
+preparation effects, integer-to-float transcendental evaluation, `char_code/2`
+type precedence, `read_term/3` EOF handling, mixed arithmetic comparison,
+`integer_rounding_function=toward_zero`, `set_prolog_flag/2` variable errors,
+and `bagof/3` answer order. STC #21 is also used to keep finite-host exhaustion
+of unbounded integer operations inside the Prolog resource-error model.
+
+Issue #66 corresponds to the newer STC arity discussion: `max_arity` describes
+compound terms. EyeProlog therefore selects `unbounded` and does not invent a
+finite predicate/procedure ceiling merely to preserve the former 65535 value.
+STC #56, which became a WG17 action item, is implemented narrowly for database
+protection: `(:-)/1-2` are static/private for modification and `clause/2`
+access, while ordinary calls retain their separate existence behavior. Other
+draft/editorial or deliberately controversial proposals (for example deleting
+standalone if-then) remain outside the Part 1 + Corrigenda 1-3 strict baseline
+until standardized or adopted as an explicit compatibility extension.
+
 ## 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` | `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.3 | Default `max_arity` | `unbounded`: EyeProlog imposes no fixed semantic ceiling on compound-term arity. Practical host allocation exhaustion is a resource condition. This flag is distinct from any potential implementation-specific procedure-arity limit; EyeProlog currently declares no separate finite procedure limit. | **defined** — `src/iso-limits.js`, `src/solver.js`, `src/parser.js`, `src/iso.js`; issue #66 regression coverage. |
 | 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. |
@@ -73,7 +73,7 @@ Status values are:
 | 8.17.3 | Other effects of `halt/0` | Terminates EyeProlog execution and returns host/process status `0`; it produces no Prolog solution. | **defined** — `HaltSignal`, `haltBuiltin()`, CLI/runner handling. |
 | 8.17.4 | Meaning/effects of `halt(Status)` | Integer `Status` is converted to the host process/runner halt code; it produces no Prolog solution. | **defined** — `haltBuiltin()`, `src/execute.js`, `src/cli.js`. |
 | 9.1.4.1 | Floating-point rounding function `rndF` | Floating values and operations use ECMAScript `Number` (IEEE-754 binary64) and the host's specified binary64 arithmetic/conversions. | **defined** — `src/iso-arithmetic.js`, `src/number-value.js`. |
-| 9.1.4.2 | Floating-point result function, including tiny non-zero arithmetic results | EyeProlog chooses `round(x)` rather than the exceptional value `underflow`. ECMAScript binary64 arithmetic therefore preserves a representable subnormal result and rounds a still-smaller result to `0.0`, consistently with float-token and `number_chars/2` input. | **defined** — arithmetic evaluation in `src/iso-arithmetic.js` and parser/number conversion; executable issue-56 regression below. |
+| 9.1.4.2 | Floating-point result function for operations whose result is governed only by `resultF` | EyeProlog chooses `round(x)` rather than the optional exceptional value `underflow`. ECMAScript binary64 arithmetic therefore preserves a representable subnormal result and rounds a still-smaller generic arithmetic result to `0.0`, consistently with float-token and `number_chars/2` input. This implementation-defined choice does not suppress the explicit mandatory underflow conditions stated separately for Part 1 `**/2`, `exp/1`, and Corrigendum 2 `^/2`. | **defined** — arithmetic evaluation in `src/iso-arithmetic.js` and parser/number conversion; strict exceptional-value regressions. |
 | 9.1.4.3 | Approximate-addition function | ECMAScript binary64 addition is used; subtraction is implemented through the corresponding host operation and all finite results remain binary64 values. | **defined** — arithmetic evaluation in `src/iso-arithmetic.js`. |
 | 9.4 | Representation of negative integers for bitwise operations | BigInt's unbounded signed binary semantics are used, equivalent to an infinite two's-complement sign extension for bitwise operations. | **defined** — `src/iso-arithmetic.js` BigInt bitwise operators. |
 | 9.4.1 | Right shift of negative integers and unusual shift counts | `>>` is arithmetic/sign-propagating. A negative count reverses direction according to JavaScript BigInt shift semantics; there is no finite integer bit-size ceiling in the Prolog model. | **defined** — `a >> b` in `src/iso-arithmetic.js`. |
@@ -86,15 +86,20 @@ Status values are:
 ### Issue #56: one underflow policy
 
 Clause 9.1.4.2 permits the processor to choose `round(x)` or the exceptional
-value `underflow` for a tiny non-zero arithmetic result. EyeProlog chooses
-`round(x)`. Because its floating-point profile is ECMAScript IEEE-754 binary64,
-representable subnormal values remain non-zero and smaller results round to
+value `underflow` for a tiny non-zero result when an operation is governed by
+the generic floating result function. EyeProlog chooses `round(x)`. Because its
+floating-point profile is ECMAScript IEEE-754 binary64, representable
+subnormal values remain non-zero and still-smaller generic results round to
 `0.0`. Float-token and `number_chars/2` input use the same finite-double
-rounding policy, so the same mathematical magnitude is no longer accepted as
-`0.0` on input while rejected as an arithmetic result.
-
-The regression suite checks both arithmetic and token input, and the existing
-`stc/float_underflow_input` conformance case covers the related input conversion.
+rounding policy.
+
+That generic implementation-defined choice is distinct from evaluable functors
+whose own error clauses prescribe underflow. In strict mode, `exp/1`, Part 1
+`**/2`, and Corrigendum 2 `^/2` therefore raise
+`evaluation_error(underflow)` when their mathematical non-zero result falls
+below the representable range and the host would otherwise round it to zero.
+The regression suite pins both sides of this boundary, while
+`stc/float_underflow_input` covers the related input conversion policy.
 
 ## Implementation-specific features required to be documented by 5.4
 

package/test/conformance/ISO-MATRIX.md

@@ -11,14 +11,14 @@ 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, Corrigendum 2 `keysort/2` variable/non-pair errors, and strict `arg/3`, `functor/3` / `=../2` error-order plus max-arity 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, Corrigendum 2 `keysort/2` variable/non-pair errors, and strict `arg/3`, `functor/3` / `=../2` error-order plus unbounded-arity/resource 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`, plus strict clause/database error and all-solutions precedence checks, including runtime static/private protection for the solver-native conjunction control construct |
+| 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.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, 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` |
-| 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 negative-power errors, float-only rounding modes, and Part 1 mixed integer/float comparison conversion |
+| 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 |
 
@@ -33,7 +33,8 @@ clause-by-clause in [ISO-IMPLEMENTATION-DEFINED.md](ISO-IMPLEMENTATION-DEFINED.m
 with *The Art of EyeProlog* remaining the implementation reference. In
 particular, the index records the unbounded integer model, `double_quotes=chars`,
 `//` rounding toward zero, the ECMAScript binary64 float policy (including the
-9.1.4.2 choice to round tiny arithmetic results rather than raise underflow),
+9.1.4.2 choice to round generic tiny results while retaining explicit
+functor-specific underflow errors),
 stream/character decisions, and the normal-profile extension boundary.
 
 This is an executable conformance/compatibility matrix, not a certification issued by an

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

@@ -9,7 +9,7 @@ wording.
 
 The purpose of this ledger is practical. Where an STC item can be expressed as
 an executable Prolog observation, EyeProlog keeps a standards-facing case under
-`test/conformance/stc/` (or points to an existing strict/WG17 case) so discussion
+`test/conformance/cases/stc/` (or points to an existing strict/WG17 case) so discussion
 of the draft can expose implementation problems before they become release
 regressions.
 
@@ -17,14 +17,22 @@ regressions.
 
 | STC item | Topic | EyeProlog evidence / finding |
 | --- | --- | --- |
+| [#17](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#17) | expression-error overlap | The strict suite pins both `X is 1/0+_` and `X is _+1/0` to `instantiation_error`, so the direct-variable rule is not masked by implementation evaluation order or a zero-divisor on the other operand. |
+| [#18](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#18) | `eof_action(error)` | Stream regressions verify the first EOF observation yields the EOF value and a subsequent read with `eof_action(error)` raises `permission_error(input,past_end_of_stream,...)`; `eof_code` and `reset` remain distinct. |
+| [#21](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#21) | unbounded-integer resource exhaustion | The strict suite now prevents host `RangeError` leakage from oversized integer shifts/powers and reports `resource_error(memory)`, consistent with the Part 1 resource-error note and the STC correction proposal. The same principle is used when unbounded `functor/3` construction exhausts a finite host resource. |
+| [#27](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#27)-[#29](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#29) | overlapping character/code/byte stream errors | Existing stream tests plus strict probes preserve argument validation before later stream-state errors where the published error clauses require it; the STC examples with an open alias produce the stated instantiation/type errors. |
+| [#32](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#32) | `number_chars/2` declarative/procedural wording | The strict suite follows the published procedural number-syntax path: `number_chars(N,['0','1'])` succeeds with `N = 1`. This records the executable behavior without treating the draft wording proposal as a new normative clause. |
 | [#37](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#37) | `clause/2` variable identity | `stc/clause_variable_identity` verifies sharing between head and body is preserved. |
 | [#39](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#39) | negative-number syntax | Covered extensively by the upstream-first WG17 syntax matrix; unary-minus read-back discrepancies found by that matrix were fixed in v1.3.27. |
 | [#40](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#40) | inexact float representation | EyeProlog uses the host IEEE-754 binary64 value and requires written floats to read back to that same value. Input underflow is covered by `stc/float_underflow_input`. |
-| [#42](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#42) | integer-to-float conversion for float functions | `stc/integer_to_float_evaluable` verifies an integer expression is accepted by `sin/1` and produces a float. |
-| [#44](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#44) | `char_code/2` error classification | Existing strict conformance cases require `representation_error(character_code)` for an integer outside the character-code set. |
+| [#41](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#41) | preparation-time `op/3` ordering | A strict parser regression verifies an `op/3` directive affects following text and cannot retroactively make preceding text parse with the new operator. The same preparation machinery is used for `set_prolog_flag/2`. |
+| [#42](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#42) | integer-to-float conversion for float functions | `stc/integer_to_float_evaluable` verifies an integer expression is accepted by `sin/1` and produces a float. The strict suite additionally verifies that an unbounded integer outside the finite binary64 range raises `evaluation_error(float_overflow)` during I->F conversion before `sin/1`, `cos/1`, `atan/1`, the Corrigendum 2 inverse/trigonometric additions, `exp/1`, `log/1`, `sqrt/1`, or `float/1` can observe a host infinity. |
+| [#44](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#44) | `char_code/2` error classification | Strict coverage distinguishes `type_error(integer,Code)` for a non-integer code from `representation_error(character_code)` for an integer outside the character-code set. |
+| [#48](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#48) | `read_term/3` option wording with `variables([])` | The strict suite verifies `read_term(T,[variables([])])` on input `T.` has no solution because the actual variable list cannot unify with `[]`; this keeps the operational option semantics clear despite the draft's wording concern. |
 | [#49](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#49) | `read_term/3` and EOF | Covered by strict reader/conformance tests and the interactive-read regressions. |
-| [#50](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#50) | mixed integer/float arithmetic comparison | **Found a bug during this audit.** EyeProlog rounded unbounded integers through JavaScript `Number`; `9007199254740993 > 9007199254740992.0` incorrectly failed. `stc/mixed_integer_float_comparison` now requires exact cross-type ordering and `max/2`/`min/2` use the same comparison. |
+| [#50](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#50) | mixed integer/float arithmetic comparison | The STC-facing normal-profile case requires exact cross-type ordering and `max/2`/`min/2` use the same comparison. `--iso-strict` deliberately retains the published Part 1 integer-to-float comparison rule; the draft case is not silently substituted for that normative baseline. |
 | [#55](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#55) | integer rounding function | Existing flag conformance verifies `integer_rounding_function = toward_zero`. |
+| [#56](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#56) | protect `(:-)/1` and `(:-)/2` from database modification | **Found a gap during the #65 audit.** Strict database operations now treat both functors as static/private for `assert*`, `retract*`, `abolish/1`, declarations, and `clause/2`, while ordinary calls still follow the separate procedure-existence behavior described by the STC item. |
 | [#58](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#58) | `set_prolog_flag/2` instantiation error | Existing strict/error coverage requires an instantiation error when a required flag value is a variable. |
 | [#67](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#67) | `bagof/3` answer-order example | `stc/bagof_answer_order` verifies the proposed clarifying example produces `[2,1]`. |
 | [#73](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#73) | float-reading limits discussed from issue #54 | Positive/negative literal and `number_chars/2` overflow are kept as explicit draft cases; underflow is tested separately. See the note below. |

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, 65535), 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, unbounded), pair(unknown, fail), pair(double_quotes, chars), pair(occurs_check, true)]).

package/test/run-iso-strict.mjs

@@ -8,6 +8,7 @@ import {
   Env,
   createStrictIsoRegistry,
   parseGoalText,
+  parseProgramText,
   run,
 } from '../src/index.js';
 import { TestReporter, isMainModule, runStandalone } from './test-style.mjs';
@@ -55,7 +56,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,65535)',
+      'current_prolog_flag(max_arity,unbounded)',
       'current_prolog_flag(unknown,error)',
       'current_prolog_flag(double_quotes,chars)',
     ]) equal(answers(goalText), 1, goalText);
@@ -71,7 +72,7 @@ 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,65535)' })).formal,
+    equal(capture(() => run('', { isoStrict: true, goal: 'set_prolog_flag(max_arity,unbounded)' })).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');
@@ -81,13 +82,21 @@ 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('keeps max_arity unbounded for compound terms', () => {
+    const program = Program.parse('', { isoStrict: true });
+    const solver = new Solver(program, { isoStrict: true });
+    const answers = (text) => [...solver.solve([parseGoalText(text, { isoStrict: true })], new Env(), 0)].length;
+    equal(answers('current_prolog_flag(max_arity,unbounded)'), 1, 'unbounded flag value');
+    equal(answers('functor(T,foo,65536),arg(65536,T,z)'), 1, 'functor beyond former 65535 ceiling');
+
+    const source = `wide(${Array.from({ length: 65536 }, () => 'a').join(',')}).`;
+    const clauses = parseProgramText(source, { isoStrict: true, sourceMetadata: true });
+    equal(clauses[0]?.head?.arity, 65536, 'source term beyond former 65535 ceiling');
+
+    // A very large predicate indicator that names no procedure must not be
+    // rounded through JavaScript Number or misreported as max_arity.
+    equal(run('', { isoStrict: true, goal: 'abolish(foo/9007199254740993)' }).stats.completed_goal_lists,
+      1, 'large nonexistent predicate indicator');
   });
 
   reporter.test('preparation-time char_conversion affects later unquoted source only', () => {
@@ -291,6 +300,50 @@ export function runIsoStrict(reporter = new TestReporter()) {
     }
   });
 
+  reporter.test('applies integer-to-float conversion before floating evaluable functors', () => {
+    const huge = `1${'0'.repeat(400)}`;
+    for (const functor of ['float', 'sin', 'cos', 'atan', 'asin', 'acos', 'tan', 'exp', 'log', 'sqrt']) {
+      equal(capture(() => run('', { isoStrict: true, goal: `X is ${functor}(${huge})` })).formal,
+        'evaluation_error(float_overflow)', `${functor}/1 integer-to-float overflow`);
+    }
+  });
+
+  reporter.test('reports explicit transcendental and power underflow in strict mode', () => {
+    for (const [goal, label] of [
+      ['X is exp(-1000.0)', 'exp/1 underflow'],
+      ['X is 2.0 ** -1075.0', '**/2 underflow'],
+      ['X is 2.0 ^ -1075.0', 'Corrigendum 2 ^/2 underflow'],
+    ]) {
+      equal(capture(() => run('', { isoStrict: true, goal })).formal,
+        'evaluation_error(underflow)', label);
+    }
+
+    equal(run('', { isoStrict: true, goal: 'X is 0.0 ** 2.0' }).stats.completed_goal_lists,
+      1, 'exact zero power remains zero');
+    equal(run('', { isoStrict: true, goal: 'X is 4.9406564584124654e-324 * 0.5' }).stats.completed_goal_lists,
+      1, 'generic resultF retains the selected round-to-zero policy');
+
+    // Keep these stricter exceptional conditions confined to --iso-strict.
+    equal(run('', { goal: 'X is exp(-1000.0)' }).stats.completed_goal_lists, 1, 'normal exp behavior');
+    equal(run('', { goal: 'X is 2.0 ** -1075.0' }).stats.completed_goal_lists, 1, 'normal power behavior');
+  });
+
+  reporter.test('preserves prescribed power errors before integer-to-float conversion', () => {
+    const hugeNegative = `-1${'0'.repeat(400)}`;
+    equal(capture(() => run('', { isoStrict: true, goal: 'X is (-2) ** 2.0' })).formal,
+      'evaluation_error(undefined)', '**/2 negative base requires integer-typed exponent');
+    equal(run('', { isoStrict: true, goal: 'X is (-2.0) ** 2' }).stats.completed_goal_lists,
+      1, '**/2 negative base with integer exponent');
+    equal(run('', { isoStrict: true, goal: 'X is (-2) ^ 2.0' }).stats.completed_goal_lists,
+      1, 'Corrigendum 2 ^/2 accepts integer-valued float exponent');
+    equal(capture(() => run('', { isoStrict: true, goal: 'X is (-2) ^ 0.5' })).formal,
+      'evaluation_error(undefined)', 'Corrigendum 2 ^/2 fractional exponent');
+    equal(capture(() => run('', { isoStrict: true, goal: `X is ${hugeNegative} ** 0.5` })).formal,
+      'evaluation_error(undefined)', 'undefined power precedes base conversion overflow');
+    equal(capture(() => run('', { isoStrict: true, goal: `X is 0.0 ** (${hugeNegative})` })).formal,
+      'evaluation_error(undefined)', 'zero-negative power precedes exponent conversion overflow');
+  });
+
   reporter.test('uses the Part 1 mixed arithmetic comparison operations', () => {
     // 8.7 converts the integer operand to float in mixed comparisons.
     equal(run('', { isoStrict: true, goal: '18014398509481985 =:= 18014398509481984.0' }).stats.completed_goal_lists,
@@ -315,11 +368,12 @@ export function runIsoStrict(reporter = new TestReporter()) {
       '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('keeps Corrigendum 2 call/N compatible with unbounded max_arity', () => {
+    // Corrigendum 2 prescribes representation_error(max_arity) only when the
+    // resulting closure exceeds a finite max_arity. With the selected
+    // `unbounded` value that conditional branch does not apply.
+    equal(run('', { isoStrict: true, goal: "call(=(x),x)" }).stdout,
+      'call(=(x), x).\n', 'call/2 closure expansion');
   });
 
   reporter.test('reports the complete List culprit for Corrigendum 2 atomic conversions', () => {
@@ -351,6 +405,48 @@ export function runIsoStrict(reporter = new TestReporter()) {
     equal(program.operators.has('xfx\u0000?-'), false, 'xfx ?-');
   });
 
+  reporter.test('pins applicable post-Corrigendum STC clarifications', () => {
+    equal(capture(() => run('', { isoStrict: true, goal: 'X is 1/0+_' })).formal,
+      'instantiation_error', 'STC 17 direct variable precedes zero divisor on the other branch');
+    equal(capture(() => run('', { isoStrict: true, goal: 'X is _+1/0' })).formal,
+      'instantiation_error', 'STC 17 is independent of operand order');
+
+    equal(run('', { isoStrict: true, goal: 'integer(- /**/ 1)' }).stats.completed_goal_lists,
+      1, 'layout between minus and integer token');
+    equal(run('', { isoStrict: true, goal: "number_chars(N,['0','1']),N=1" }).stats.completed_goal_lists,
+      1, 'STC 32 number_chars/2 follows the procedural number syntax for leading zero');
+
+    const shared = run(
+      ':- dynamic(a/1).\na(X) :- b(X).\n',
+      { isoStrict: true, goal: 'clause(a(A),b(B)),A==B,A=ok' },
+    );
+    equal(shared.stats.completed_goal_lists, 1, 'clause/2 preserves head/body variable identity');
+
+    equal(capture(() => run('', { isoStrict: true, goal: 'char_code(_,c)' })).formal,
+      'type_error(integer)', 'char_code/2 non-integer code');
+    equal(capture(() => run('', { isoStrict: true, goal: 'set_prolog_flag(unknown,_)' })).formal,
+      'instantiation_error', 'set_prolog_flag/2 variable value');
+    equal(run('', {
+      isoStrict: true,
+      goal: 'read(T),T=end_of_file',
+      ioOptions: { input: '' },
+    }).stats.completed_goal_lists, 1, 'read/1 end_of_file');
+    includes(run('', {
+      isoStrict: true,
+      goal: 'bagof(X,(X=2;X=1),S),S=[2,1],X=ok',
+    }).stdout, '[2, 1]', 'bagof/3 preserves answer order');
+
+    Program.parse(':- op(500,xfx,foo).\na foo b.\n', { isoStrict: true });
+    const beforeDefinition = capture(() => Program.parse('a foo b.\n:- op(500,xfx,foo).\n', { isoStrict: true }));
+    includes(beforeDefinition.message, 'expected .', 'STC 41 op/3 directive applies only to following text');
+
+    equal(run('', {
+      isoStrict: true,
+      goal: 'read_term(T,[variables([])])',
+      ioOptions: { input: 'T.' },
+    }).stats.completed_goal_lists, 0, 'STC 48 variables([]) does not match an input variable');
+  });
+
   reporter.test('rejects EyeProlog module directives', () => {
     const error = capture(() => Program.parse(':- use_module(library(lists)).\n', { isoStrict: true }));
     includes(error.message, 'implementation-specific directive use_module/1', 'message');
@@ -400,6 +496,41 @@ export function runIsoStrict(reporter = new TestReporter()) {
       'permission_error(access, private_procedure)', 'clause/2 conjunction access');
   });
 
+  reporter.test('protects directive and rule functors from database modification per STC 56', () => {
+    const protectedGoals = [
+      "asserta(((':-'(a,b)):-true))",
+      "asserta(((':-'(b)):-true))",
+      "assertz(((':-'(a,b)):-true))",
+      "retract((':-'(a,b):-true))",
+      "retractall((':-'(a,b):-true))",
+      "abolish('/'(':-',2))",
+      "abolish('/'(':-',1))",
+    ];
+    for (const goal of protectedGoals) {
+      equal(capture(() => run('', { isoStrict: true, goal })).formal,
+        'permission_error(modify, static_procedure)', goal);
+    }
+    equal(capture(() => run('', { isoStrict: true, goal: "clause(':-'(a,b),_)" })).formal,
+      'permission_error(access, private_procedure)', 'clause/2 (:-)/2 access');
+    equal(capture(() => run('', { isoStrict: true, goal: "clause(':-'(b),_)" })).formal,
+      'permission_error(access, private_procedure)', 'clause/2 (:-)/1 access');
+    equal(capture(() => run('', { isoStrict: true, goal: "call(':-'(a,b))" })).formal,
+      'existence_error(procedure)', 'STC 56 keeps calls distinct from modification');
+    equal(capture(() => Program.parse(":- dynamic('/'(':-',2)).\n", { isoStrict: true })).formal,
+      'permission_error(modify, static_procedure)', 'preparation-time (:-)/2 declaration protection');
+  });
+
+  reporter.test('reports finite host exhaustion without imposing ISO representation bounds', () => {
+    equal(capture(() => run('', { isoStrict: true, goal: 'functor(T,f,4294967296)' })).formal,
+      'resource_error(memory)', 'unbounded max_arity host array exhaustion');
+    equal(capture(() => run('', { isoStrict: true, goal: 'X is 1 << 4294967296' })).formal,
+      'resource_error(memory)', 'unbounded integer shift host exhaustion');
+    equal(capture(() => run('', { isoStrict: true, goal: 'X is 2 ^ 4294967296' })).formal,
+      'resource_error(memory)', 'unbounded integer power host exhaustion');
+    equal(run('', { isoStrict: true, goal: 'current_prolog_flag(max_arity,unbounded)' }).stats.completed_goal_lists,
+      1, 'resource handling does not reintroduce a finite max_arity');
+  });
+
   reporter.test('covers ISO database predicate errors and empty-procedure lifetime', () => {
     const errors = [
       ['current_predicate(4)', '', 'type_error(predicate_indicator)'],

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` | `65535` | `65535` | no |
+| `max_arity` | `unbounded` | `unbounded` | no |
 | `unknown` | `error` | `error`, `fail`, `warning` | yes |
 | `double_quotes` | `chars` | `chars`, `codes`, `atom` | yes |
 | `occurs_check` | `true` | `true`, `error` | yes |