eyeprolog 1.5.54 → 1.5.56

package/README.md

@@ -73,7 +73,6 @@ printf 'human(socrates).\nmortal(X) :- human(X).\n' |
 - [ISO conformance review](test/conformance/ISO-COMPLIANCE.md) — supported Part 1 profile
 - [Latest Neumerkel conformity](test/conformance/NEUMERKEL-LATEST.md) — tracked result from the current live upstream inventory
 - [Conformance report](conformance-report.md) — generated executable conformance status, local corpus summary, and known deviations
-- [Acknowledgements](ACKNOWLEDGEMENTS.md) — funding, standards consulted, and credits for vendored conformance corpora
 - [OpenRuleBench](openrulebench/README.md) — portable benchmark profile
 ## RDF, Prolog, and symbiotic knowledge graphs
 

package/conformance-report.md

@@ -70,3 +70,24 @@ runs that corpus live through the Neumerkel gate; the offline regression
 suite runs all 58 vendored quads. Neither expectations nor error matching
 are relaxed for quads 41-44.
 
+
+## Integer flag choice under `bounded=false`
+
+EyeProlog reports `bounded=false` and uses arbitrary-precision integers.
+It therefore associates no current value with `max_integer` or
+`min_integer`, so `current_prolog_flag/2` does not enumerate them and
+fails when either is named. Both flags stay registered, so
+`set_prolog_flag/2` still reaches the normal non-changeable-flag errors.
+
+This is an implementation choice, not a requirement of Part 1. Clause
+7.11.1.1 defines the `bounded` flag and does not govern
+`current_prolog_flag/2` outcomes, while 7.11.1.2 and 7.11.1.3 give both
+flags an implementation-defined default value unconditionally; the
+`bounded` condition constrains what that value *means*, not whether the
+flag exists. Two alternative readings are equally defensible: expose
+implementation-defined values so the flags enumerate, or treat them as
+unsupported and raise `domain_error(prolog_flag, Flag)` per 8.17.2.3 b.
+EyeProlog prefers silence over inventing a largest integer that its
+arithmetic does not have. The vendored Prologue corpus records the
+resulting single divergence rather than patching the upstream fixture.
+

package/examples/combinatorics-findall-sort.pl

@@ -14,16 +14,16 @@
 
 % select/3 nondeterministically removes one item from a list; because it is an
 % ordinary rule, the example also demonstrates user-level list recursion.
-select(Item, [Item | Rest], Rest).
+select_item(Item, [Item | Rest], Rest).
 % The recursive clause keeps the non-selected head and searches the tail.
-select(Item, [Head | Tail], [Head | Rest]) :-
-  select(Item, Tail, Rest).
+select_item(Item, [Head | Tail], [Head | Rest]) :-
+  select_item(Item, Tail, Rest).
 
 % combination/3 builds an unordered K-combination by repeated selection.
 combination(0, _items, []).
 combination(I, Items, Combination) :-
   (I > 0),
-  select(Item, Items, Remaining),
+  select_item(Item, Items, Remaining),
   (J is I - 1),
   combination(J, Remaining, Partial),
   sort([Item | Partial], Combination).

package/examples/d3-group.pl

@@ -21,42 +21,42 @@ symmetry(reflection_b).
 symmetry(reflection_c).
 
 % Cayley table for D3 composition.
-compose(identity, identity, identity).
-compose(identity, rotation_120, rotation_120).
-compose(identity, rotation_240, rotation_240).
-compose(identity, reflection_a, reflection_a).
-compose(identity, reflection_b, reflection_b).
-compose(identity, reflection_c, reflection_c).
-compose(rotation_120, identity, rotation_120).
-compose(rotation_120, rotation_120, rotation_240).
-compose(rotation_120, rotation_240, identity).
-compose(rotation_120, reflection_a, reflection_b).
-compose(rotation_120, reflection_b, reflection_c).
-compose(rotation_120, reflection_c, reflection_a).
-compose(rotation_240, identity, rotation_240).
-compose(rotation_240, rotation_120, identity).
-compose(rotation_240, rotation_240, rotation_120).
-compose(rotation_240, reflection_a, reflection_c).
-compose(rotation_240, reflection_b, reflection_a).
-compose(rotation_240, reflection_c, reflection_b).
-compose(reflection_a, identity, reflection_a).
-compose(reflection_a, rotation_120, reflection_c).
-compose(reflection_a, rotation_240, reflection_b).
-compose(reflection_a, reflection_a, identity).
-compose(reflection_a, reflection_b, rotation_240).
-compose(reflection_a, reflection_c, rotation_120).
-compose(reflection_b, identity, reflection_b).
-compose(reflection_b, rotation_120, reflection_a).
-compose(reflection_b, rotation_240, reflection_c).
-compose(reflection_b, reflection_a, rotation_120).
-compose(reflection_b, reflection_b, identity).
-compose(reflection_b, reflection_c, rotation_240).
-compose(reflection_c, identity, reflection_c).
-compose(reflection_c, rotation_120, reflection_b).
-compose(reflection_c, rotation_240, reflection_a).
-compose(reflection_c, reflection_a, rotation_240).
-compose(reflection_c, reflection_b, rotation_120).
-compose(reflection_c, reflection_c, identity).
+compose_op(identity, identity, identity).
+compose_op(identity, rotation_120, rotation_120).
+compose_op(identity, rotation_240, rotation_240).
+compose_op(identity, reflection_a, reflection_a).
+compose_op(identity, reflection_b, reflection_b).
+compose_op(identity, reflection_c, reflection_c).
+compose_op(rotation_120, identity, rotation_120).
+compose_op(rotation_120, rotation_120, rotation_240).
+compose_op(rotation_120, rotation_240, identity).
+compose_op(rotation_120, reflection_a, reflection_b).
+compose_op(rotation_120, reflection_b, reflection_c).
+compose_op(rotation_120, reflection_c, reflection_a).
+compose_op(rotation_240, identity, rotation_240).
+compose_op(rotation_240, rotation_120, identity).
+compose_op(rotation_240, rotation_240, rotation_120).
+compose_op(rotation_240, reflection_a, reflection_c).
+compose_op(rotation_240, reflection_b, reflection_a).
+compose_op(rotation_240, reflection_c, reflection_b).
+compose_op(reflection_a, identity, reflection_a).
+compose_op(reflection_a, rotation_120, reflection_c).
+compose_op(reflection_a, rotation_240, reflection_b).
+compose_op(reflection_a, reflection_a, identity).
+compose_op(reflection_a, reflection_b, rotation_240).
+compose_op(reflection_a, reflection_c, rotation_120).
+compose_op(reflection_b, identity, reflection_b).
+compose_op(reflection_b, rotation_120, reflection_a).
+compose_op(reflection_b, rotation_240, reflection_c).
+compose_op(reflection_b, reflection_a, rotation_120).
+compose_op(reflection_b, reflection_b, identity).
+compose_op(reflection_b, reflection_c, rotation_240).
+compose_op(reflection_c, identity, reflection_c).
+compose_op(reflection_c, rotation_120, reflection_b).
+compose_op(reflection_c, rotation_240, reflection_a).
+compose_op(reflection_c, reflection_a, rotation_240).
+compose_op(reflection_c, reflection_b, rotation_120).
+compose_op(reflection_c, reflection_c, identity).
 % Each candidate subgroup must also contain inverses.
 inverse(identity, identity).
 inverse(rotation_120, rotation_240).
@@ -78,7 +78,7 @@ all_symmetries(Symmetries) :-
 
 % A valid subgroup is closed under both composition and inverse.
 closed_under_composition(Group) :-
-  \+ (member(X, Group), member(Y, Group), compose(X, Y, Z), \+ member(Z, Group)).
+  \+ (member(X, Group), member(Y, Group), compose_op(X, Y, Z), \+ member(Z, Group)).
 
 closed_under_inverse(Group) :-
   \+ (member(X, Group), inverse(X, Y), \+ member(Y, Group)).

package/examples/eulerian-path.pl

@@ -39,9 +39,9 @@ incident(V, E) :- edge(E, _u, V).
 adjacent_by_edge(V, U, E) :- edge(E, V, U).
 adjacent_by_edge(V, U, E) :- edge(E, U, V).
 
-select(Item, [Item | Rest], Rest).
-select(Item, [Head | Tail], [Head | Rest]) :-
-  select(Item, Tail, Rest).
+select_item(Item, [Item | Rest], Rest).
+select_item(Item, [Head | Tail], [Head | Rest]) :-
+  select_item(Item, Tail, Rest).
 
 % Eulerian paths start at an odd-degree vertex when exactly two exist.
 odd_degree(V) :-
@@ -77,7 +77,7 @@ eulerian_path(Path) :-
 dfs_euler(_current, Path, [], Path).
 dfs_euler(Current, Visited, Remaining, Path) :-
   adjacent_by_edge(Current, Next, Edge),
-  select(Edge, Remaining, Newremaining),
+  select_item(Edge, Remaining, Newremaining),
   dfs_euler(Next, [Next | Visited], Newremaining, Path).
 
 oddVertices(eulerian_path_case, Odds) :-

package/examples/graph-reachability.pl

@@ -18,14 +18,14 @@ edge(d, f).
 edge(e, f).
 edge(f, g).
 
-reachable(Node, Node, _visited).
-reachable(Start, Goal, Visited) :-
+reachable_via(Node, Node, _visited).
+reachable_via(Start, Goal, Visited) :-
   edge(Start, Next),
   \+ member(Next, Visited),
-  reachable(Next, Goal, [Next|Visited]).
+  reachable_via(Next, Goal, [Next|Visited]).
 
 is_reachable(Start, Goal) :-
-  reachable(Start, Goal, [Start]).
+  reachable_via(Start, Goal, [Start]).
 
 reachable(reachability_case, path(a, f)) :-
   is_reachable(a, f).

package/examples/monkey-bananas.pl

@@ -20,16 +20,16 @@ plan(Moves) :-
   candidate_plan(Moves),
   initial_state(I),
   goal_state(G),
-  reachable(I, Moves, G).
+  reachable_state(I, Moves, G).
 
 candidate_plan([_, _, _]).
 candidate_plan([_, _, _, _]).
 candidate_plan([_, _, _, _, _]).
 
-reachable(S, [], S).
-reachable(S1, [M|L], S3) :-
+reachable_state(S, [], S).
+reachable_state(S1, [M|L], S3) :-
   legal_move(S1, M, S2),
-  reachable(S2, L, S3).
+  reachable_state(S2, L, S3).
 
 initial_state([loc1, loc2, loc3, n, n]).
 goal_state([_, _, _, _, y]).

package/examples/proof/graph-reachability.pl

@@ -11,7 +11,7 @@ why(
         bindings([binding("Start", a), binding("Goal", f)]),
         uses([
           proof(
-            goal(reachable(a, f, "a")),
+            goal(reachable_via(a, f, "a")),
             by(rule("graph-reachability.pl", clause(9))),
             bindings([binding("Start", a), binding("Goal", f), binding("Visited", "a"), binding("Next", b)]),
             uses([
@@ -24,7 +24,7 @@ why(
                 by(builtin('\\+', 1))
               ),
               proof(
-                goal(reachable(b, f, "ba")),
+                goal(reachable_via(b, f, "ba")),
                 by(rule("graph-reachability.pl", clause(9))),
                 bindings([binding("Start", b), binding("Goal", f), binding("Visited", "ba"), binding("Next", d)]),
                 uses([
@@ -37,7 +37,7 @@ why(
                     by(builtin('\\+', 1))
                   ),
                   proof(
-                    goal(reachable(d, f, "dba")),
+                    goal(reachable_via(d, f, "dba")),
                     by(rule("graph-reachability.pl", clause(9))),
                     bindings([binding("Start", d), binding("Goal", f), binding("Visited", "dba"), binding("Next", f)]),
                     uses([
@@ -50,7 +50,7 @@ why(
                         by(builtin('\\+', 1))
                       ),
                       proof(
-                        goal(reachable(f, f, "fdba")),
+                        goal(reachable_via(f, f, "fdba")),
                         by(fact("graph-reachability.pl", clause(8))),
                         bindings([binding("Node", f), binding("_visited", "fdba")])
                       )
@@ -79,7 +79,7 @@ why(
         bindings([binding("Start", c), binding("Goal", g)]),
         uses([
           proof(
-            goal(reachable(c, g, "c")),
+            goal(reachable_via(c, g, "c")),
             by(rule("graph-reachability.pl", clause(9))),
             bindings([binding("Start", c), binding("Goal", g), binding("Visited", "c"), binding("Next", e)]),
             uses([
@@ -92,7 +92,7 @@ why(
                 by(builtin('\\+', 1))
               ),
               proof(
-                goal(reachable(e, g, "ec")),
+                goal(reachable_via(e, g, "ec")),
                 by(rule("graph-reachability.pl", clause(9))),
                 bindings([binding("Start", e), binding("Goal", g), binding("Visited", "ec"), binding("Next", f)]),
                 uses([
@@ -105,7 +105,7 @@ why(
                     by(builtin('\\+', 1))
                   ),
                   proof(
-                    goal(reachable(f, g, "fec")),
+                    goal(reachable_via(f, g, "fec")),
                     by(rule("graph-reachability.pl", clause(9))),
                     bindings([binding("Start", f), binding("Goal", g), binding("Visited", "fec"), binding("Next", g)]),
                     uses([
@@ -118,7 +118,7 @@ why(
                         by(builtin('\\+', 1))
                       ),
                       proof(
-                        goal(reachable(g, g, "gfec")),
+                        goal(reachable_via(g, g, "gfec")),
                         by(fact("graph-reachability.pl", clause(8))),
                         bindings([binding("Node", g), binding("_visited", "gfec")])
                       )

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.5.54",
+  "version": "1.5.56",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",
@@ -28,7 +28,6 @@
   "files": [
     "LICENSE.md",
     "README.md",
-    "ACKNOWLEDGEMENTS.md",
     "index.js",
     "index.d.ts",
     "playground.html",

package/src/cli.js

@@ -196,6 +196,10 @@ export async function main(argv) {
   });
 
   const portabilityFailures = program.interopPortabilityWarnings ?? [];
+  // Shadowing is reported unconditionally: silently replacing a library
+  // predicate for the whole program is the failure mode this diagnostic exists
+  // to surface, so it must not depend on opting in to --warnings.
+  printLibraryShadowingWarnings(program);
   if (options.warnings || (options.portable && portabilityFailures.length > 0)) printWarnings(program);
   if (options.portable && portabilityFailures.length > 0) {
     process.exitCode = 1;
@@ -364,6 +368,14 @@ function printSourceWarning(warning) {
 `);
 }
 
+function printLibraryShadowingWarnings(program) {
+  for (const warning of program.libraryShadowingWarnings ?? []) {
+    process.stderr.write('eyeprolog warning: user definition shadows a bundled library predicate\n');
+    process.stderr.write(`  ${warning.indicator} replaces library(${warning.library}) ${warning.indicator} for all user code in this program\n`);
+    process.stderr.write(`  import it explicitly with :- use_module(library(${warning.library}), [${warning.indicator}]). to make this an error\n`);
+  }
+}
+
 function printWarnings(program) {
   for (const warning of program.interopPortabilityWarnings ?? []) {
     if (warning.kind === 'library') {

package/src/datalog.js

@@ -32,7 +32,7 @@ function sameScalar(left, right) {
   return scalarKey(left) === scalarKey(right);
 }
 
-export class DatalogRelation {
+class DatalogRelation {
   constructor(arity) {
     this.arity = arity;
     this.rows = [];

package/src/expansion-builtins.js

@@ -66,7 +66,7 @@ function sourceTermList(term, env) {
   return null;
 }
 
-export function systemExpandTerm(term, module = 'user') {
+function systemExpandTerm(term, module = 'user') {
   const resolved = deref(term, new Env());
   if (resolved.type === COMPOUND && resolved.name === '-->' && resolved.arity === 2) {
     const expanded = expandDcgRuleClause({ head: resolved, body: [] }, module);

package/src/iso-character.js

@@ -23,13 +23,3 @@ export function isStrictIsoPcsCharacter(character) {
   if (typeof character !== 'string' || Array.from(character).length !== 1) return false;
   return isStrictIsoPcsCodePoint(character.codePointAt(0));
 }
-
-// EyeProlog chooses the Unicode scalar value as the collating-sequence integer.
-export function strictIsoCollatingInteger(character) {
-  return isStrictIsoPcsCharacter(character) ? character.codePointAt(0) : null;
-}
-
-export function assertStrictIsoPcsCharacter(character, formal = 'representation_error(character)') {
-  if (!isStrictIsoPcsCharacter(character)) throw new CharacterRepresentationError(formal);
-  return character;
-}

package/src/iso.js

@@ -35,7 +35,7 @@ class ThrownTerm extends Error {
 const succeed = function* ({ env }) { yield env; };
 const fail = function* () {};
 
-export const isoBuiltins = {
+const isoBuiltins = {
   register(registry) {
     registry.add('true', 0, succeed, { deterministic: true });
     registry.add('fail', 0, fail, { deterministic: true });
@@ -956,10 +956,15 @@ function* currentPrologFlagSolutions({ solver, goal, env }, state) {
     .filter(([name, definition]) => definition.value != null && (flag.type === VAR || flag.name === name));
   for (let index = 0; index < definitions.length; index++) {
     const [name, definition] = definitions[index];
-    // ISO 7.11.1.1: when bounded=false, max_integer and min_integer have no
-    // current value and current_prolog_flag/2 must therefore not enumerate
-    // them. The definitions remain registered so attempts to change these
-    // non-changeable flags still receive the normal flag error handling.
+    // Implementation choice: with bounded=false there is no largest integer to
+    // report, so max_integer and min_integer carry no current value and are not
+    // enumerated. ISO 7.11.1.1 defines the bounded flag and does not govern
+    // current_prolog_flag/2; 7.11.1.2 and 7.11.1.3 give both flags an
+    // implementation-defined default unconditionally, so the alternative
+    // reading (expose values, or raise domain_error(prolog_flag)) is equally
+    // available. See conformance-report.md. The definitions remain registered
+    // so attempts to change these non-changeable flags still receive the
+    // normal flag error handling.
     const next = env.clone();
     if (unify(goal.args[0], atom(name), next) && unify(goal.args[1], definition.value, next)) {
       state.pending = index + 1 < definitions.length;
@@ -1802,15 +1807,6 @@ function parseReadTermText(text, solver) {
   });
 }
 
-export function isCompleteReadTermText(text, solver) {
-  try {
-    parseReadTermText(text, solver);
-    return true;
-  } catch (_) {
-    return false;
-  }
-}
-
 function readTermFromStream(stream, solver) {
   if (stream.pastEnd && stream.eofAction === 'error') {
     throw new PrologError('permission_error(input, past_end_of_stream)', streamHandle(stream.id));

package/src/program-analysis.js

@@ -16,13 +16,13 @@ export function componentHasNegativeEdge(start, deps, negativeEdges) {
   return negativeEdges.some(([from, to]) => component.has(from) && component.has(to));
 }
 
-export function compactClauseIsDirectRecursive(clause, group) {
+function compactClauseIsDirectRecursive(clause, group) {
   return isCompactBinaryClause(clause) && clause.bodyName === group.name && group.arity === 2;
 }
 
 
 
-export function clauseIsDirectRecursive(clause, group) {
+function clauseIsDirectRecursive(clause, group) {
   if (isCompactBinaryClause(clause)) return compactClauseIsDirectRecursive(clause, group);
   return clause.body.some((goal) =>
     goal.type === COMPOUND && goal.name === group.name && goal.arity === group.arity
@@ -86,7 +86,7 @@ function reachableIndexesTransposed(target, deps, candidates) {
 }
 
 
-export function isFiniteDatalogArgument(term) {
+function isFiniteDatalogArgument(term) {
   return term?.type === VAR || term?.type === ATOM || term?.type === 'string' || term?.type === 'number';
 }
 
@@ -289,7 +289,7 @@ export function isFiniteWfsDatalogGroup(program, group, cache = new Map(), visit
   return finite;
 }
 
-export function collectVariables(term, output) {
+function collectVariables(term, output) {
   if (!term) return;
   if (term.type === VAR) {
     output.add(term.name);
@@ -420,12 +420,12 @@ export function isPortableBetweenGenerator(group) {
     group.clauses.every((clause) => clause.eyePrologLibraryPortable === true);
 }
 
-export function termContainsVariable(term, name) {
+function termContainsVariable(term, name) {
   if (term.type === 'var') return term.name === name;
   return term.args.some((arg) => termContainsVariable(arg, name));
 }
 
-export function sameClauseTerm(left, right) {
+function sameClauseTerm(left, right) {
   if (left.type !== right.type || left.name !== right.name || left.args.length !== right.args.length) return false;
   return left.args.every((arg, index) => sameClauseTerm(arg, right.args[index]));
 }
@@ -446,7 +446,7 @@ export function directGoalDependencyKey(goal) {
 }
 
 // ISO 13211-1, 7.1.6.3: `V1^V2^...^Goal` has the iterated goal Goal.
-export function iteratedGoal(goal) {
+function iteratedGoal(goal) {
   let current = goal;
   while (current?.type === COMPOUND && current.name === '^' && current.arity === 2) {
     current = current.args[1];

package/src/program-indexing.js

@@ -68,14 +68,6 @@ export function compactHeadArgName(clause, index) {
   return index === 0 ? clause.head0Name : clause.head1Name;
 }
 
-export function compactBodyArgType(clause, index) {
-  return index === 0 ? clause.body0Type : clause.body1Type;
-}
-
-export function compactBodyArgName(clause, index) {
-  return index === 0 ? clause.body0Name : clause.body1Name;
-}
-
 export function clauseBodyLength(clause) {
   return isCompactBinaryClause(clause) ? (clause.bodyName == null ? 0 : 1) : clause.body.length;
 }

package/src/program.js

@@ -153,6 +153,7 @@ export class Program {
     this.autoloadedPredicates = [];
     this.libraryImports = [];
     this.interopPortabilityWarnings = [];
+    this.libraryShadowingWarnings = [];
     this.dynamicPredicates = new Set();
     // ISO 7.5.3 notes that a public/1 directive declaring user-defined
     // procedures to be public would be an extension. Such a procedure stays
@@ -1428,6 +1429,50 @@ function analyzeInteropPortability(program, extraGoals = []) {
     });
   }
   program.interopPortabilityWarnings = [...warnings.values()];
+  analyzeLibraryShadowing(program);
+}
+
+// A user-defined procedure replaces the bundled-library procedure of the same
+// name and arity: the library clauses are never autoloaded, so other parts of
+// the same program that expected the library behaviour just see the user's
+// clauses. Bundled library modules keep resolving their own internal calls, so
+// this only affects user code, but within user code it acts at a distance
+// across included files.
+//
+// How strictly this is treated depends on how explicit the program was, which
+// follows the graded scheme SWI-Prolog uses for the same situation:
+//
+//   implicit autoload                          -> warning
+//   use_module(library(L))                     -> warning
+//   use_module(library(L), [Name/Arity])       -> permission_error
+//
+// Only the last case is an outright contradiction: the program asked for that
+// exact predicate to be imported and then supplied clauses for it. The first
+// two stay warnings so that flat, module-free programs -- which load unchanged
+// on Scryer and Trealla, where the library is simply never imported -- keep
+// working. Note that ISO reserves permission_error(modify, static_procedure)
+// for built-in predicates (7.5.3); library predicates are not built-ins, so
+// this error is raised only where the program's own import list demands it.
+function analyzeLibraryShadowing(program) {
+  const explicitlyImported = new Map();
+  for (const entry of program.libraryImports) {
+    if (entry.imports == null) continue;
+    for (const indicator of entry.imports) {
+      explicitlyImported.set(`${entry.targetModule}:${indicator.key}`, entry.library);
+    }
+  }
+
+  const shadowed = new Map();
+  for (const group of program.groups.values()) {
+    if (group.module !== 'user') continue;
+    const key = `${group.name}/${group.arity}`;
+    const explicitLibrary = explicitlyImported.get(`${group.module}:${key}`);
+    if (explicitLibrary != null) throw staticProcedureModificationError(group.name, group.arity);
+    const library = eyePrologLibraryAutoload[key];
+    if (library == null || shadowed.has(key)) continue;
+    shadowed.set(key, { kind: 'shadowed-library-predicate', indicator: key, library });
+  }
+  program.libraryShadowingWarnings = [...shadowed.values()];
 }
 
 function sourceOptionsFor(source, options) {
@@ -1940,7 +1985,3 @@ function predicateIndicator(name, arity) {
 export function makeProgram(source, options = {}) {
   return Program.parse(source, options);
 }
-
-export function parseSourceClauses(source, options = {}) {
-  return parseClauses(source, options);
-}

package/test/conformance/ISO-COMPLIANCE.md

@@ -58,7 +58,9 @@ concrete mismatches that are now part of the closed Part 1 review:
 
 - `bounded=false` no longer exposes implementation-specific `unbounded` values
   for `max_integer` or `min_integer`; the corresponding
-  `current_prolog_flag/2` queries fail as specified by 7.11.1.1;
+  `current_prolog_flag/2` queries fail. Part 1 does not require that outcome
+  (7.11.1.1 defines the `bounded` flag and does not govern
+  `current_prolog_flag/2`), so it is recorded as an implementation choice;
 - preparation-time `char_conversion/2` now converts later unquoted source text
   when the `char_conversion` flag is `on`, leaves quoted characters unchanged,
   and feeds the same mapping into execution-time term input.

package/test/conformance/ISO-PROLOG-TEXT-EXECUTION-MATRIX.md

@@ -23,7 +23,7 @@ chosen behavior is also indexed by `ISO-IMPLEMENTATION-DEFINED.md`.
 | 7.4.2.7 `include/1` | covered | The included text is prepared at the directive position and shares operator/character/flag preparation state with its parent. |
 | 7.4.2.8 `ensure_loaded/1` | covered | A source is prepared at most once in the current load graph, including repeated references and self/top-level references. |
 | 7.4.2.9 `set_prolog_flag/2` | covered | Preparation-time flag changes affect subsequent text and are replayed into execution state; strict flag names/values/changeability remain governed by the closed 7.11 review. |
-| 7.4.3 source clauses | covered | Source heads/bodies are validated like program clauses, standardized static/control procedures are protected, declarations can create empty procedures, and body conversion follows 7.6.2 while preserving head/body variable identity. The built-in restriction applies in every execution mode, so consulting a clause for a built-in predicate or control construct reports the same `permission_error(modify, static_procedure)` as `assert`ing one; EyeProlog's own library and extension predicates are not standard built-ins and stay redefinable. Corpus: `error/iso/consult_redefines_builtin`. |
+| 7.4.3 source clauses | covered | Source heads/bodies are validated like program clauses, standardized static/control procedures are protected, declarations can create empty procedures, and body conversion follows 7.6.2 while preserving head/body variable identity. The built-in restriction applies in every execution mode, so consulting a clause for a built-in predicate or control construct reports the same `permission_error(modify, static_procedure)` as `assert`ing one; EyeProlog's own library and extension predicates are not standard built-ins, so ISO does not protect them. They stay redefinable when they reach the program implicitly, through autoloading or a whole-module `use_module(library(L))`, but the redefinition is reported as a shadowing warning because it replaces the library predicate for all user code in the program. Naming a predicate in an explicit import list, `use_module(library(L), [Name/Arity])`, and then supplying clauses for it is a contradiction and reports `permission_error(modify, static_procedure)`. Bundled library modules keep resolving their own internal calls, so a user redefinition never changes library behaviour. Corpus: `error/iso/consult_redefines_builtin`. |
 
 The strict release test `closes ISO 7.4 Prolog-text preparation and directive
 rows` exercises the cross-text operator/character/flag state, include and

package/test/fixtures/README.md

@@ -32,7 +32,9 @@ included before its examples are run.
 
 The upstream Prologue snapshot contains one `max_integer` quad that accepts an
 implementation-specific `Max = unbounded` result. EyeProlog deliberately does
-not patch that vendored fixture: with its ISO `bounded=false` choice, Part 1
-7.11.1.1 requires `current_prolog_flag(max_integer, _)` to fail. The regression
-gate therefore records this single standards-driven divergence explicitly while
-requiring the other 32 quads to pass.
+not patch that vendored fixture: with `bounded=false` it reports no value for
+`max_integer`, so `current_prolog_flag(max_integer, _)` fails. Part 1 does not
+mandate that outcome -- 7.11.1.1 defines the `bounded` flag and says nothing
+about `current_prolog_flag/2` -- so this is an implementation choice, not a
+standards requirement. The regression gate records the single divergence
+explicitly while requiring the other 32 quads to pass.