eyeprolog 1.3.2 → 1.3.4

package/README.md

@@ -143,12 +143,20 @@ Trealla/Scryer organization for predicates such as `member/2`, `memberchk/2`,
 `length(Xs, N)` enumerates lists of increasing length together with `N = 0, 1,
 2, ...`.
 
+`library(iso_ext)` is also accepted as a common interop module name.
+EyeProlog exports `call_nth/2` there, so Scryer-style source can explicitly use
+`:- use_module(library(iso_ext)).`; unqualified source may still autoload it.
+The aligned `library(lists)` and `library(iso_ext)` exports are kept disjoint so
+they can be imported together without an accidental import conflict. EyeProlog's
+legacy `library(prologue)` remains a compatibility umbrella and should be
+selectively imported when mixed with the aligned modules.
+
 Outside `--iso-strict`, an otherwise undefined unqualified call may autoload a
 predicate only when the interop profile has one canonical EyeProlog provider.
-For example, `member/2` autoloads from `library(lists)`, while `between/3` and
-`call_nth/2` can use EyeProlog's internal Prologue implementation without
-requiring portable source to name `library(prologue)`. Use `--no-autoload` to
-disable this convenience. Strict ISO mode never autoloads library predicates.
+For example, `member/2` autoloads from `library(lists)`, `call_nth/2` from
+`library(iso_ext)`, and `between/3` from EyeProlog's internal
+`library(prologue)` implementation. Use `--no-autoload` to disable this
+convenience. Strict ISO mode never autoloads library predicates.
 
 Use `-w` / `--warnings` to diagnose dependencies outside the interop profile,
 or `--portable` to make such diagnostics fail the run. This catches both

package/examples/book/chapter-08/01-findall.pl

@@ -1,6 +1,7 @@
 % From The Art of EyeProlog, Chapter 8.
 :- use_module(library(aggregate)).
 :- use_module(library(lists)).
+:- use_module(library(iso_ext)).
 
 findall(Template, Goal, List).
 countall(Goal, Count).

package/examples/book/chapter-39/04-cost.pl

@@ -1,6 +1,7 @@
 % From The Art of EyeProlog, Chapter 39.
 :- use_module(library(aggregate)).
 :- use_module(library(lists)).
+:- use_module(library(iso_ext)).
 
 cost(a, 8).
 cost(b, 3).

package/examples/chart-parser.pl

@@ -1,4 +1,5 @@
 :- use_module(library(lists)).
+:- use_module(library(iso_ext)).
 
 % A tiny automatically tabled chart parser for a context-free grammar.
 %

package/examples/dog.pl

@@ -1,4 +1,5 @@
 :- use_module(library(lists)).
+:- use_module(library(iso_ext)).
 
 % Dog-license compliance rule adapted from Eyeling dog.n3.
 %

package/examples/donald-gerald-robert.pl

@@ -1,4 +1,5 @@
 :- use_module(library(lists)).
+:- use_module(library(iso_ext)).
 
 % A pandigital cryptarithm: DONALD + GERALD = ROBERT.
 %

package/examples/equality-saturation.pl

@@ -1,6 +1,7 @@
 :- use_module(library(aggregate)).
 :- use_module(library(prologue), [between/3]).
 :- use_module(library(lists)).
+:- use_module(library(iso_ext)).
 
 % Bounded equality saturation over tiny arithmetic expression terms.
 %

package/examples/job-shop-scheduling.pl

@@ -1,6 +1,7 @@
 :- use_module(library(aggregate)).
 :- use_module(library(prologue), [between/3]).
 :- use_module(library(lists)).
+:- use_module(library(iso_ext)).
 
 % Tiny job-shop scheduling benchmark.
 %

package/examples/knapsack-optimization.pl

@@ -1,5 +1,6 @@
 :- use_module(library(aggregate)).
 :- use_module(library(lists)).
+:- use_module(library(iso_ext)).
 
 % 0/1 knapsack optimization with aggregate_max/5.
 %

package/examples/knuth-bendix-completion.pl

@@ -1,4 +1,5 @@
 :- use_module(library(lists)).
+:- use_module(library(iso_ext)).
 
 % Bounded Knuth-Bendix-style completion for append/2 terms.
 %

package/examples/matrix-chain-order.pl

@@ -1,6 +1,7 @@
 :- use_module(library(aggregate)).
 :- use_module(library(prologue), [between/3]).
 :- use_module(library(lists)).
+:- use_module(library(iso_ext)).
 
 % Matrix-chain multiplication order by automatically tabled interval dynamic programming.
 %

package/examples/missionaries-cannibals.pl

@@ -1,5 +1,6 @@
 :- use_module(library(prologue), [between/3]).
 :- use_module(library(lists)).
+:- use_module(library(iso_ext)).
 
 % Missionaries-and-cannibals river crossing as guarded state-space search.
 %

package/examples/prime-range.pl

@@ -1,5 +1,6 @@
 :- use_module(library(prologue), [between/3]).
 :- use_module(library(lists)).
+:- use_module(library(iso_ext)).
 
 % Prime ranges and Euler totient over finite integer domains.
 %

package/examples/register-allocation.pl

@@ -1,5 +1,6 @@
 :- use_module(library(aggregate)).
 :- use_module(library(lists)).
+:- use_module(library(iso_ext)).
 
 % Register allocation as bounded graph coloring with spilling.
 %

package/examples/send-more-money.pl

@@ -1,4 +1,5 @@
 :- use_module(library(lists)).
+:- use_module(library(iso_ext)).
 
 % Cryptarithm search for SEND + MORE = MONEY.
 %

package/examples/stable-marriage.pl

@@ -1,4 +1,5 @@
 :- use_module(library(lists)).
+:- use_module(library(iso_ext)).
 
 % Stable-marriage search with explicit blocking-pair detection.
 %

package/examples/totient-summatory.pl

@@ -1,6 +1,7 @@
 :- use_module(library(aggregate)).
 :- use_module(library(prologue), [between/3]).
 :- use_module(library(lists)).
+:- use_module(library(iso_ext)).
 
 % Euler totients and coprimality by automatically tabled Euclidean gcd.
 %

package/examples/weighted-interval-scheduling.pl

@@ -1,5 +1,6 @@
 :- use_module(library(aggregate)).
 :- use_module(library(lists)).
+:- use_module(library(iso_ext)).
 
 % Weighted interval scheduling via automatically tabled dynamic programming.
 %

package/package.json

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

package/src/iso.js

@@ -6,7 +6,7 @@ import {
   properListItems, termIsGround, termToString, unify, variable, variantTerms,
 } from './term.js';
 import { sameNumberValue } from './number-value.js';
-import { createParserOperatorState, parseClauses, parseGoalText, parseNumberTokenText } from './parser.js';
+import { createParserOperatorState, parseGoalText, parseNumberTokenText, parseTermText } from './parser.js';
 import { formatTermForWrite } from './write.js';
 import { emptyTerminalSequence, expandDcgBody, isListOrPartialList, validateDcgEmbeddedGoals } from './dcg.js';
 import {
@@ -1199,8 +1199,7 @@ function scopeReadTerm(term) {
 function parseReadTermText(text, solver) {
   const converted = convertedTermText(text, solver);
   const operatorState = createParserOperatorState(solver.program.operators.values(), false);
-  const clauses = parseClauses(converted, {
-    sourceMetadata: false,
+  return parseTermText(converted, {
     operatorState,
     isoStrict: solver.isoStrict,
     doubleQuotes: solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
@@ -1208,8 +1207,6 @@ function parseReadTermText(text, solver) {
     // Earlier ambiguous dots must remain available to maximal graphic tokens.
     readTermEnd: converted.length - 1,
   });
-  if (clauses.length !== 1 || clauses[0].body.length) throw new Error('bad term');
-  return clauses[0].head;
 }
 
 export function isCompleteReadTermText(text, solver) {
@@ -2035,11 +2032,28 @@ function prologErrorBall(error) {
   return freshCopy(term, new Env());
 }
 function* catchBuiltin({ solver, goal, env }) {
-  const child = solver.cloneForInnerGoal();
+  let child = null;
   try {
     // Corrigendum 2 removed catch/3's own callability errors so that errors
     // raised while converting/executing the protected goal are catchable.
-    yield* child.solve([callable(goal.args[0], env)], env.clone(), 0);
+    const invoked = callable(goal.args[0], env);
+    const direct = solver.registry.get(invoked.name, invoked.arity);
+    if (direct?.deterministic && (direct.shouldUse == null || direct.shouldUse({ solver, goal: invoked, env }))) {
+      // A deterministic builtin has no choice points whose lifetime must be
+      // isolated in a child solver. Running it directly avoids constructing a
+      // complete Solver for hot caught failures such as number_chars/2 syntax
+      // probes, while the cloned environment keeps catch/3's rollback boundary.
+      const iterator = direct.handler({ solver, goal: invoked, env: env.clone() });
+      const result = iterator.next();
+      if (result.done) solver.stats.deterministic_builtin_failures++;
+      else {
+        solver.stats.deterministic_builtin_successes++;
+        yield result.value;
+      }
+      return;
+    }
+    child = solver.cloneForInnerGoal();
+    yield* child.solve([invoked], env.clone(), 0);
   } catch (error) {
     const ball = error instanceof ThrownTerm
       ? error.term
@@ -2049,9 +2063,15 @@ function* catchBuiltin({ solver, goal, env }) {
     if (ball == null) throw error;
     const recovered = env.clone();
     if (!unify(goal.args[1], ball, recovered)) throw error;
-    yield* solver.solve([callable(goal.args[2], recovered)], recovered, 0);
+    const recovery = callable(goal.args[2], recovered);
+    if (recovery.type === ATOM && (recovery.name === 'false' || recovery.name === 'fail')) return;
+    if (recovery.type === ATOM && recovery.name === 'true') {
+      yield recovered;
+      return;
+    }
+    yield* solver.solve([recovery], recovered, 0);
   } finally {
-    solver.absorbStatsFrom(child);
+    if (child != null) solver.absorbStatsFrom(child);
   }
 }
 function* throwBuiltin({ goal, env }) {
@@ -2074,7 +2094,20 @@ function* repeatBuiltin({ env }) {
   while (true) yield env;
 }
 function* negationBuiltin({ solver, goal, env }) {
-  for (const _ of solver.cloneForInnerGoal(1).solve([callable(goal.args[0], env)], env.clone(), 0)) return;
+  const invoked = callable(goal.args[0], env);
+  const direct = solver.registry.get(invoked.name, invoked.arity);
+  if (direct?.deterministic && (direct.shouldUse == null || direct.shouldUse({ solver, goal: invoked, env }))) {
+    const iterator = direct.handler({ solver, goal: invoked, env: env.clone() });
+    const result = iterator.next();
+    if (result.done) {
+      solver.stats.deterministic_builtin_failures++;
+      yield env;
+    } else {
+      solver.stats.deterministic_builtin_successes++;
+    }
+    return;
+  }
+  for (const _ of solver.cloneForInnerGoal(1).solve([invoked], env.clone(), 0)) return;
   yield env;
 }
 function* solveControlBranch(solver, goal, env) {

package/src/lib/iso_ext.pl

@@ -1,6 +1,7 @@
 /** Widely implemented extensions to the ISO Prolog core. */
 
 :- module(iso_ext, [
+    call_nth/2,
     countall/2,
     forall/2,
     succ/2,
@@ -9,6 +10,7 @@
     variant/2
 ]).
 
+:- meta_predicate(call_nth(0, '?')).
 :- meta_predicate(countall(0, '?')).
 :- meta_predicate(forall(0, 0)).
 :- meta_predicate(findall('?', 0, '?', '?')).
@@ -17,6 +19,8 @@
 % Trealla. These definitions use only EyeProlog's ISO profile; extensions that
 % require runtime cleanup, choice-point, alarm, or timeout hooks are omitted.
 
+call_nth(Goal, Nth) :- eyeprolog__call_nth(Goal, Nth).
+
 countall(Goal, Count) :- eyeprolog__countall(Goal, Count).
 
 forall(Condition, Action) :-

package/src/lib/lists.pl

@@ -28,7 +28,6 @@
     min_list/2,
     max_list/2,
     list_to_set/2,
-    countall/2,
     set_nth0/4,
     take/3,
     drop/3,
@@ -45,7 +44,6 @@
 :- meta_predicate(foldl(3, '?', '?', '?')).
 :- meta_predicate(foldl(4, '?', '?', '?', '?')).
 :- meta_predicate(foldl(5, '?', '?', '?', '?', '?')).
-:- meta_predicate(countall(0, '?')).
 
 % Common pure-Prolog library predicates for EyeProlog.
 %
@@ -168,7 +166,6 @@ max_list([X|Xs], Max) :- lists__max_list(Xs, X, Max).
 
 list_to_set(List, Set) :- lists__list_to_set(List, [], Set).
 
-countall(Goal, Count) :- eyeprolog__countall(Goal, Count).
 
 set_nth0(0, [_|Xs], X, [X|Xs]).
 set_nth0(N, [Y|Ys], X, [Y|Zs]) :-

package/src/parser.js

@@ -819,6 +819,16 @@ class Parser {
     }
     throw new Error(`parse line ${this.token.line}: bad term`);
   }
+  parseStandaloneTerm() {
+    // read/1 and read_term/* consume one ordinary Prolog term, not a program
+    // clause. In particular, commas and operators such as :- and ?- belong to
+    // the term itself and must not be reinterpreted by parseProgram().
+    const term = this.parseTerm(0, true, true, true);
+    this.expect(TOK.DOT, '.');
+    this.advance();
+    this.expect(TOK.EOF, 'end of input');
+    return term;
+  }
   sourceLineIsIndented(line) {
     let start = 0;
     for (let current = 1; current < line; current++) {
@@ -1504,6 +1514,10 @@ export function parseNumberTokenText(text) {
   return numberTerm(source);
 }
 
+export function parseTermText(text, options = {}) {
+  return new Parser(text, options).parseStandaloneTerm();
+}
+
 export function parseGoalText(text, options = {}) {
   const clauses = parseClauses(`zz_goal((${text})).`, options);
   const head = clauses[0]?.head;

package/src/solver.js

@@ -374,7 +374,24 @@ export class Solver {
         }
         qualifyMetaArguments(goal, group);
 
-        const lengthIterator = prologueLengthIterator(this, group, goal, env);
+        const memberIterator = bundledMemberIterator(this, group, goal, env);
+        if (memberIterator != null) {
+          const firstResult = memberIterator.next();
+          if (firstResult.done) break;
+          stack.push({
+            kind: 'resumeBuiltin',
+            iterator: memberIterator,
+            goals: rest,
+            depth: depth + 1,
+            active,
+          });
+          goals = rest;
+          env = firstResult.value;
+          depth++;
+          continue;
+        }
+
+        const lengthIterator = bundledLengthIterator(this, group, goal, env);
         if (lengthIterator != null) {
           const firstResult = lengthIterator.next();
           if (firstResult.done) break;
@@ -757,9 +774,36 @@ function groupNeedsActiveFrame(group) {
   return group.cutReachable !== false || (group.recursive && !group.linearNumeric);
 }
 
-function prologueLengthIterator(solver, group, goal, env) {
+function bundledMemberIterator(solver, group, goal, env) {
+  if (solver.registry.eyePrologLibrary !== true ||
+      !['lists', 'prologue'].includes(group.module) || group.name !== 'member' || group.arity !== 2 ||
+      group.bundledLibrary !== true || group.clauses.length !== 2) {
+    return null;
+  }
+
+  // Keep the relational/open-list cases in ordinary Prolog.  When the second
+  // argument is already a finite list, however, the canonical two-clause
+  // member/2 definition is exactly a left-to-right scan and can avoid clause
+  // freshening and recursive solver frames for every element.
+  let cursor = deref(goal.args[1], env);
+  while (isCons(cursor)) cursor = deref(cursor.args[1], env);
+  if (!isEmptyList(cursor)) return null;
+  return bundledMemberSolutions(solver, goal, env);
+}
+
+function* bundledMemberSolutions(solver, goal, env) {
+  let cursor = deref(goal.args[1], env);
+  while (isCons(cursor)) {
+    const next = env.clone();
+    solver.stats.unify_calls++;
+    if (unify(goal.args[0], cursor.args[0], next)) yield next;
+    cursor = deref(cursor.args[1], env);
+  }
+}
+
+function bundledLengthIterator(solver, group, goal, env) {
   if (solver.registry.eyePrologLibrary !== true ||
-      group.module !== 'prologue' || group.name !== 'length' || group.arity !== 2 ||
+      !['lists', 'prologue'].includes(group.module) || group.name !== 'length' || group.arity !== 2 ||
       group.bundledLibrary !== true || group.clauses.length !== 2) {
     return null;
   }
@@ -778,10 +822,10 @@ function prologueLengthIterator(solver, group, goal, env) {
     if (env._delays?.has(cursor.name)) return null;
     if (length.type === VAR && cursor.name === length.name) return null;
   }
-  return prologueLengthSolutions(solver, goal, env);
+  return bundledLengthSolutions(solver, goal, env);
 }
 
-function* prologueLengthSolutions(solver, goal, env) {
+function* bundledLengthSolutions(solver, goal, env) {
   const requestedLength = deref(goal.args[1], env);
   if (requestedLength.type !== VAR) {
     if (requestedLength.type !== NUMBER || !isDecimalInteger(requestedLength.name)) {

package/src/standard-library.js

@@ -109,10 +109,10 @@ export const eyePrologInteropAutoload = Object.freeze({
   'foldl/6': 'lists',
   'sum_list/2': 'lists',
   'list_to_set/2': 'lists',
-  // call_nth/2 is available in both Trealla and Scryer (the latter via
-  // library(iso_ext)).  EyeProlog keeps its adapter in library(prologue), so
-  // autoloading hides that implementation-specific location from source.
-  'call_nth/2': 'prologue',
+  // call_nth/2 is available in both Trealla and Scryer.  EyeProlog exposes
+  // it from library(iso_ext), matching the explicit Scryer import while still
+  // allowing Trealla-style unqualified source to use the same autoload entry.
+  'call_nth/2': 'iso_ext',
   // Trealla and Scryer expose between/3 without an EyeProlog-style
   // library(prologue) dependency.  EyeProlog keeps its implementation in the
   // Prologue module but autoloads it so portable source need not name that
@@ -125,9 +125,9 @@ export const eyePrologInteropLibraryIndicators = Object.freeze(
 );
 
 // Libraries whose *name* is part of the current interop profile.  A program
-// may freely use_module(library(lists)); predicates in that module which are
-// outside eyePrologInteropLibraryIndicators are still diagnosed when used.
-export const eyePrologInteropLibraryModules = Object.freeze(['lists']);
+// may freely use_module/1 with these common module names; predicates in those
+// modules outside eyePrologInteropLibraryIndicators are still diagnosed when used.
+export const eyePrologInteropLibraryModules = Object.freeze(['lists', 'iso_ext']);
 
 function runtimeStatistics(solver) {
   return { ...solver.stats, ...memoryStatistics() };

package/test/run-conformance.mjs

@@ -18,6 +18,7 @@ function withStandardModules(text) {
   return `:- use_module(library(aggregate)).
 :- use_module(library(comparison)).
 :- use_module(library(dates)).
+:- use_module(library(iso_ext)).
 :- use_module(library(lists)).
 :- use_module(library(primes)).
 :- use_module(library(prologue), [between/3]).

package/test/run-regression.mjs

@@ -20,6 +20,7 @@ import {
   createDefaultRegistry,
   getStrictIsoRegistry,
   getEyePrologRegistry,
+  standardLibrarySources,
   eyePrologLibraryIndicators,
   eyePrologNativeLibraryIndicators,
   eyePrologPortableLibraryIndicators,
@@ -67,6 +68,7 @@ function withStandardModules(source) {
   return `:- use_module(library(aggregate)).
 :- use_module(library(comparison)).
 :- use_module(library(dates)).
+:- use_module(library(iso_ext)).
 :- use_module(library(lists)).
 :- use_module(library(primes)).
 :- use_module(library(prologue), [between/3]).
@@ -819,6 +821,27 @@ c4 ?- call((!;1)).
         });
         assertEqual(consecutive.stdout, "answer(./*., ok).\n", 'following read starts after the complete term');
 
+        // Issue #41 follow-up: read/1 consumes an ordinary term, not a program
+        // clause head. A comma chain therefore has no program-level two-comma
+        // limit, and source operators such as :- and ?- remain term data.
+        const commaChain = runEyeProlog('', {
+          goal: 'read(T)',
+          ioOptions: { input: '!,!,! .\n' },
+        });
+        assertEqual(commaChain.stdout, 'read((!, !, !)).\n', 'three-element comma term');
+
+        const ruleAsData = runEyeProlog('', {
+          goal: 'read(T)',
+          ioOptions: { input: 'a :- b.\n' },
+        });
+        assertEqual(ruleAsData.stdout, 'read((a :- b)).\n', 'rule operator remains term data');
+
+        const queryAsData = runEyeProlog('', {
+          goal: 'read(T)',
+          ioOptions: { input: '?- foo.\n' },
+        });
+        assertEqual(queryAsData.stdout, 'read((?- foo)).\n', 'query operator remains term data');
+
         // A possible full stop can fail to complete the term while still
         // extending a current graphic operator into an ordinary atom.  The
         // later standalone full stop then completes the read term.  Exercise
@@ -2193,6 +2216,22 @@ child.stdin.write(\`consult(${consultedAtom}).\\n\`);
         assertEqual(result.stderr, '', 'stderr');
       },
     },
+    {
+      name: 'library(lists) and library(iso_ext) co-import without collisions',
+      run: () => {
+        const input = [
+          ':- use_module(library(lists)).',
+          ':- use_module(library(iso_ext)).',
+          '%% goal: answer(N)',
+          'answer(N) :- call_nth(member(_, [a,b,c]), N), N = 2.',
+          '',
+        ].join('\n');
+        const result = runCli(['--portable', '--no-autoload', '-'], { input });
+        assertEqual(result.status, 0, 'exit status');
+        assertEqual(result.stdout, 'answer(2).\n', 'stdout');
+        assertEqual(result.stderr, '', 'stderr');
+      },
+    },
     {
       name: 'strict ISO mode disables interop autoloading',
       run: () => {
@@ -3597,10 +3636,10 @@ check(A, B, C, D, E, F) :-
         assertEqual(registeredNativeEyePrologLibraryNames().length, 40, 'public native EyeProlog builtin count');
         assertEqual(eyePrologPortableLibraryIndicators.length, 62, 'portable Prolog library count');
         assertEqual(eyePrologInteropLibraryIndicators.length, 27, 'cross-implementation interop profile count');
-        assertEqual(eyePrologInteropLibraryModules.join(','), 'lists', 'common explicit library module profile');
+        assertEqual(eyePrologInteropLibraryModules.join(','), 'lists,iso_ext', 'common explicit library module profile');
         assertEqual(eyePrologInteropAutoload['member/2'], 'lists', 'member/2 canonical autoload');
         assertEqual(eyePrologInteropAutoload['between/3'], 'prologue', 'between/3 canonical internal autoload');
-        assertEqual(eyePrologInteropAutoload['call_nth/2'], 'prologue', 'call_nth/2 canonical internal autoload');
+        assertEqual(eyePrologInteropAutoload['call_nth/2'], 'iso_ext', 'call_nth/2 canonical interop autoload');
         assertEqual(eyePrologInteropAutoload['set_nth0/4'] ?? null, null, 'EyeProlog-only set_nth0/4 is not autoloadable');
         assertEqual(eyePrologNativeLibraryIndicators.length, 40, 'native host library count');
         assertEqual(eyePrologNativeLibraryIndicators.slice(0, 2).join(','), 'call_nth/2,freeze/2', 'control predicates requiring host support');
@@ -3650,6 +3689,28 @@ check(A, B, C, D, E, F) :-
         assertEqual(program.findGroup('random', 3)?.module, 'random', 'random/3 is imported from library(random)');
       },
     },
+    {
+      name: 'aligned bundled libraries have no overlapping full-module exports',
+      run: () => {
+        const owners = new Map();
+        for (const [moduleName, entry] of standardLibrarySources) {
+          // library(prologue) is the documented legacy compatibility umbrella;
+          // aligned libraries must remain pairwise collision-free so full
+          // use_module/1 imports can be combined safely.
+          if (moduleName === 'prologue') continue;
+          const parsed = Program.parse(entry.source);
+          const definition = parsed.modules.get(moduleName);
+          if (!definition) throw new Error(`missing module declaration for ${moduleName}`);
+          for (const indicator of definition.exports.keys()) {
+            const previous = owners.get(indicator);
+            if (previous != null) throw new Error(`duplicate export ${indicator}: ${previous}, ${moduleName}`);
+            owners.set(indicator, moduleName);
+          }
+        }
+        assertEqual(owners.get('countall/2'), 'iso_ext', 'countall/2 has one aligned owner');
+        assertEqual(owners.get('call_nth/2'), 'iso_ext', 'call_nth/2 has one aligned owner');
+      },
+    },
     {
       name: 'portable library executes against the ISO-only registry',
       run: () => {

package/the-art-of-eyeprolog.md

@@ -1155,6 +1155,7 @@ Finite aggregation asks about a solution set:
 ```eyeprolog
 :- use_module(library(aggregate)).
 :- use_module(library(lists)).
+:- use_module(library(iso_ext)).
 
 findall(Template, Goal, List).
 countall(Goal, Count).
@@ -6019,8 +6020,8 @@ between solution branches.
 | `library(clpz)` | `#>/2`, `#</2`, `#>=/2`, `#=</2`, `#=/2`, `#\=/2`, `#\/1`, `#<==>/2`, `#==>/2`, `#<==/2`, `#\//2`, `#\/2`, `#/\/2`, `in/2`, `ins/2`, `all_different/1`, `all_distinct/1`, `nvalue/2`, `sum/3`, `scalar_product/4`, `tuples_in/2`, `labeling/2`, `label/1`, `indomain/1`, `lex_chain/1`, `serialized/2`, `global_cardinality/2`, `global_cardinality/3`, `circuit/1`, `chain/2`, `element/3`, `zcompare/3`, `fd_var/1`, `fd_inf/2`, `fd_sup/2`, `fd_size/2`, `fd_dom/2` |
 | `library(comparison)` | `lt/2`, `gt/2`, `le/2`, `ge/2` |
 | `library(dates)` | `difference/3` |
-| `library(iso_ext)` | `countall/2`, `forall/2`, `succ/2`, `cfor/3`, `findall/4`, `variant/2` |
-| `library(lists)` | `member/2`, `memberchk/2`, `select/3`, `append/2`, `append/3`, `last/2`, `same_length/2`, `nth0/3`, `nth0/4`, `nth1/3`, `nth1/4`, `reverse/2`, `length/2`, `maplist/2`, `maplist/3`, `maplist/4`, `maplist/5`, `maplist/6`, `maplist/7`, `maplist/8`, `foldl/4`, `foldl/5`, `foldl/6`, `sum_list/2`, `min_list/2`, `max_list/2`, `list_to_set/2`, `countall/2`, `set_nth0/4`, `take/3`, `drop/3`, `slice/4` |
+| `library(iso_ext)` | `call_nth/2`, `countall/2`, `forall/2`, `succ/2`, `cfor/3`, `findall/4`, `variant/2` |
+| `library(lists)` | `member/2`, `memberchk/2`, `select/3`, `append/2`, `append/3`, `last/2`, `same_length/2`, `nth0/3`, `nth0/4`, `nth1/3`, `nth1/4`, `reverse/2`, `length/2`, `maplist/2`, `maplist/3`, `maplist/4`, `maplist/5`, `maplist/6`, `maplist/7`, `maplist/8`, `foldl/4`, `foldl/5`, `foldl/6`, `sum_list/2`, `min_list/2`, `max_list/2`, `list_to_set/2`, `set_nth0/4`, `take/3`, `drop/3`, `slice/4` |
 | `library(primes)` | `smallest_divisor_from/3` |
 | `library(prologue)` | `member/2`, `append/3`, `length/2`, `between/3`, `select/3`, `succ/2`, `maplist/2`, `maplist/3`, `maplist/4`, `maplist/5`, `maplist/6`, `maplist/7`, `maplist/8`, `nth0/3`, `nth0/4`, `nth1/3`, `nth1/4`, `call_nth/2`, `freeze/2`, `foldl/4`, `foldl/5`, `foldl/6`, `countall/2` |
 | `library(random)` | `random/3` |
@@ -6046,14 +6047,21 @@ This generator mode is important for portable stress and enumeration programs.
 EyeProlog-only helpers such as `set_nth0/4`, `take/3`, `drop/3`, and `slice/4`
 remain available for compatibility but are outside this profile.
 
+`library(iso_ext)` is also recognized as a common interop module name.
+EyeProlog exports `call_nth/2` there, matching Scryer's explicit import
+organization while still permitting unqualified autoloaded source. The aligned
+`library(lists)` and `library(iso_ext)` export sets are intentionally disjoint,
+so a source file may import both without an accidental predicate collision.
+`library(prologue)` is retained as an EyeProlog compatibility umbrella and may
+overlap these modules; use selective imports when legacy code combines it with
+the aligned libraries.
+
 Normal EyeProlog execution can autoload an otherwise undefined unqualified call
 only when the interop table assigns it one canonical provider. Thus `member/2`
-autoloads from `library(lists)`. `between/3` and `call_nth/2` are also in the
-interop profile; EyeProlog can satisfy them from its internal
-`library(prologue)` implementation without forcing portable source to mention
-that EyeProlog-specific library name. Autoloading is disabled by
-`--no-autoload`, by the JavaScript option `autoload: false`, and always by
-`--iso-strict`.
+autoloads from `library(lists)`, `call_nth/2` from `library(iso_ext)`, and
+`between/3` from the internal `library(prologue)` implementation. Autoloading is
+disabled by `--no-autoload`, by the JavaScript option `autoload: false`, and
+always by `--iso-strict`.
 
 `-w` / `--warnings` reports explicit non-profile library dependencies and calls
 to non-profile predicates from common libraries. `--portable` turns those
@@ -6075,11 +6083,14 @@ cumulative and two-dimensional scheduling constraints, and unbounded-domain
 propagation that are not yet exported here.
 
 `library(iso_ext)` collects extensions commonly found in mature Prolog
-systems. `forall/2` checks an action for every solution of a condition;
-`cfor/3` enumerates an inclusive evaluated integer range; `succ/2` relates
-adjacent nonnegative integers; `findall/4` collects into a difference list;
-and `variant/2` recognizes terms equal up to variable renaming. Its portable
-`countall/2` counts solutions without exposing a template.
+systems. `call_nth/2` exposes the ordinal number of each solution and supports
+the explicit import used by Scryer-style source; `forall/2` checks an action for
+every solution of a condition; `cfor/3` enumerates an inclusive evaluated
+integer range; `succ/2` relates adjacent nonnegative integers; `findall/4`
+collects into a difference list; and `variant/2` recognizes terms equal up to
+variable renaming. Its portable `countall/2` counts solutions without exposing
+a template. `countall/2` is not exported by `library(lists)`, avoiding a
+full-module import collision between the two libraries.
 
 `uuid(+Seed0,-UUID,-Seed)` creates a version 4 UUID atom using `random/3`.
 Passing the returned seed to the next call produces the next UUID; restarting
@@ -6272,6 +6283,7 @@ There is no `not/1` alias; use ISO `\+/1`. `forall/2` is available from
 ```eyeprolog
 :- use_module(library(aggregate)).
 :- use_module(library(lists)).
+:- use_module(library(iso_ext)).
 
 cost(a, 8).
 cost(b, 3).