eyeprolog 1.2.44 → 1.3.0

package/README.md

@@ -123,8 +123,8 @@ noun --> [world] | [prolog].
 %% goal: phrase(sentence, Words)
 ```
 
-EyeProlog also adds 99 public library predicate indicators to its 129-entry ISO
-profile. **60 are implemented entirely as ordinary Prolog clauses** in focused
+EyeProlog also adds 102 public library predicate indicators to its 129-entry ISO
+profile. **63 are implemented entirely as ordinary Prolog clauses** in focused
 modules under `src/lib/`; the control predicates and finite-domain
 `library(clpz)` kernel use backtrackable host support.
 They are ISO/IEC 13211-2 modules loaded explicitly by purpose, such as
@@ -133,6 +133,35 @@ Portable text
 predicates use ISO atoms or character lists. The old catch-all
 `library(eyeprolog)` module is no longer needed.
 
+## Trealla and Scryer interoperability
+
+EyeProlog keeps a conservative source-level interoperability profile separate
+from the larger EyeProlog library surface. `library(lists)` follows the common
+Trealla/Scryer organization for predicates such as `member/2`, `memberchk/2`,
+`append/2-3`, `nth0/3-4`, `nth1/3-4`, `maplist/2-8`, and `foldl/4-6`.
+
+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)` and `between/3` 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.
+
+Use `-w` / `--warnings` to diagnose dependencies outside the interop profile,
+or `--portable` to make such diagnostics fail the run. This catches both
+implementation-specific library names and EyeProlog-only predicates such as
+`set_nth0/4` even when they live in an otherwise common module.
+
+Cross-engine smoke tests live in `test/run-interop.mjs`. With Trealla (`tpl`)
+and Scryer (`scryer-prolog`) installed, run:
+
+```sh
+npm run test:interop
+```
+
+The GitHub interoperability workflow builds both implementations and runs the
+same portable Sudoku source under EyeProlog, Trealla, and Scryer.
+
 ## Development
 
 ```sh

package/examples/book/chapter-06/03-square.pl

@@ -1,5 +1,4 @@
 % From The Art of EyeProlog, Chapter 6.
-:- use_module(library(prologue), [between/3]).
 :- use_module(library(lists)).
 
 square(N, Square) :-

package/examples/fast-fourier-transform.pl

@@ -1,3 +1,5 @@
+:- use_module(library(lists), [memberchk/2]).
+
 % Fast Fourier Transform
 % Code from the book "Clause and Effect" Chapter 10
 

package/examples/output/fast-fourier-transform.pl

@@ -1 +1 @@
-fft([0, 1, 2, 3, 4, 5, 6, 7], [n(232, op(+, 216, 231)), n(231, op(*, 217, 230)), n(230, op(+, 222, 229)), n(229, op(*, 223, 228)), n(228, op(+, 224, 227)), n(227, op(*, 225, 226)), n(226, a(7)), n(225, w ^ 4), n(224, a(3)), n(223, w ^ 6), n(222, op(+, 218, 221)), n(221, op(*, 219, 220)), n(220, a(5)), n(219, w ^ 4), n(218, a(1)), n(217, w ^ 7), n(216, op(+, 208, 215)), n(215, op(*, 209, 214)), n(214, op(+, 210, 213)), n(213, op(*, 211, 212)), n(212, a(6)), n(211, w ^ 4), n(210, a(2)), n(209, w ^ 6), n(208, op(+, 204, 207)), n(207, op(*, 205, 206)), n(206, a(4)), n(205, w ^ 4), n(204, a(0)), n(203, op(+, 187, 202)), n(202, op(*, 188, 201)), n(201, op(+, 193, 200)), n(200, op(*, 194, 199)), n(199, op(+, 195, 198)), n(198, op(*, 196, 197)), n(197, a(7)), n(196, w ^ 0), n(195, a(3)), n(194, w ^ 4), n(193, op(+, 189, 192)), n(192, op(*, 190, 191)), n(191, a(5)), n(190, w ^ 0), n(189, a(1)), n(188, w ^ 6), n(187, op(+, 179, 186)), n(186, op(*, 180, 185)), n(185, op(+, 181, 184)), n(184, op(*, 182, 183)), n(183, a(6)), n(182, w ^ 0), n(181, a(2)), n(180, w ^ 4), n(179, op(+, 175, 178)), n(178, op(*, 176, 177)), n(177, a(4)), n(176, w ^ 0), n(175, a(0)), n(174, op(+, 158, 173)), n(173, op(*, 159, 172)), n(172, op(+, 164, 171)), n(171, op(*, 165, 170)), n(170, op(+, 166, 169)), n(169, op(*, 167, 168)), n(168, a(7)), n(167, w ^ 4), n(166, a(3)), n(165, w ^ 2), n(164, op(+, 160, 163)), n(163, op(*, 161, 162)), n(162, a(5)), n(161, w ^ 4), n(160, a(1)), n(159, w ^ 5), n(158, op(+, 150, 157)), n(157, op(*, 151, 156)), n(156, op(+, 152, 155)), n(155, op(*, 153, 154)), n(154, a(6)), n(153, w ^ 4), n(152, a(2)), n(151, w ^ 2), n(150, op(+, 146, 149)), n(149, op(*, 147, 148)), n(148, a(4)), n(147, w ^ 4), n(146, a(0)), n(145, op(+, 129, 144)), n(144, op(*, 130, 143)), n(143, op(+, 135, 142)), n(142, op(*, 136, 141)), n(141, op(+, 137, 140)), n(140, op(*, 138, 139)), n(139, a(7)), n(138, w ^ 0), n(137, a(3)), n(136, w ^ 0), n(135, op(+, 131, 134)), n(134, op(*, 132, 133)), n(133, a(5)), n(132, w ^ 0), n(131, a(1)), n(130, w ^ 4), n(129, op(+, 121, 128)), n(128, op(*, 122, 127)), n(127, op(+, 123, 126)), n(126, op(*, 124, 125)), n(125, a(6)), n(124, w ^ 0), n(123, a(2)), n(122, w ^ 0), n(121, op(+, 117, 120)), n(120, op(*, 118, 119)), n(119, a(4)), n(118, w ^ 0), n(117, a(0)), n(116, op(+, 100, 115)), n(115, op(*, 101, 114)), n(114, op(+, 106, 113)), n(113, op(*, 107, 112)), n(112, op(+, 108, 111)), n(111, op(*, 109, 110)), n(110, a(7)), n(109, w ^ 4), n(108, a(3)), n(107, w ^ 6), n(106, op(+, 102, 105)), n(105, op(*, 103, 104)), n(104, a(5)), n(103, w ^ 4), n(102, a(1)), n(101, w ^ 3), n(100, op(+, 92, 99)), n(99, op(*, 93, 98)), n(98, op(+, 94, 97)), n(97, op(*, 95, 96)), n(96, a(6)), n(95, w ^ 4), n(94, a(2)), n(93, w ^ 6), n(92, op(+, 88, 91)), n(91, op(*, 89, 90)), n(90, a(4)), n(89, w ^ 4), n(88, a(0)), n(87, op(+, 71, 86)), n(86, op(*, 72, 85)), n(85, op(+, 77, 84)), n(84, op(*, 78, 83)), n(83, op(+, 79, 82)), n(82, op(*, 80, 81)), n(81, a(7)), n(80, w ^ 0), n(79, a(3)), n(78, w ^ 4), n(77, op(+, 73, 76)), n(76, op(*, 74, 75)), n(75, a(5)), n(74, w ^ 0), n(73, a(1)), n(72, w ^ 2), n(71, op(+, 63, 70)), n(70, op(*, 64, 69)), n(69, op(+, 65, 68)), n(68, op(*, 66, 67)), n(67, a(6)), n(66, w ^ 0), n(65, a(2)), n(64, w ^ 4), n(63, op(+, 59, 62)), n(62, op(*, 60, 61)), n(61, a(4)), n(60, w ^ 0), n(59, a(0)), n(58, op(+, 42, 57)), n(57, op(*, 43, 56)), n(56, op(+, 48, 55)), n(55, op(*, 49, 54)), n(54, op(+, 50, 53)), n(53, op(*, 51, 52)), n(52, a(7)), n(51, w ^ 4), n(50, a(3)), n(49, w ^ 2), n(48, op(+, 44, 47)), n(47, op(*, 45, 46)), n(46, a(5)), n(45, w ^ 4), n(44, a(1)), n(43, w ^ 1), n(42, op(+, 34, 41)), n(41, op(*, 35, 40)), n(40, op(+, 36, 39)), n(39, op(*, 37, 38)), n(38, a(6)), n(37, w ^ 4), n(36, a(2)), n(35, w ^ 2), n(34, op(+, 30, 33)), n(33, op(*, 31, 32)), n(32, a(4)), n(31, w ^ 4), n(30, a(0)), n(29, op(+, 13, 28)), n(28, op(*, 14, 27)), n(27, op(+, 19, 26)), n(26, op(*, 20, 25)), n(25, op(+, 21, 24)), n(24, op(*, 22, 23)), n(23, a(7)), n(22, w ^ 0), n(21, a(3)), n(20, w ^ 0), n(19, op(+, 15, 18)), n(18, op(*, 16, 17)), n(17, a(5)), n(16, w ^ 0), n(15, a(1)), n(14, w ^ 0), n(13, op(+, 5, 12)), n(12, op(*, 6, 11)), n(11, op(+, 7, 10)), n(10, op(*, 8, 9)), n(9, a(6)), n(8, w ^ 0), n(7, a(2)), n(6, w ^ 0), n(5, op(+, 1, 4)), n(4, op(*, 2, 3)), n(3, a(4)), n(2, w ^ 0), n(1, a(0))]).
+fft([0, 1, 2, 3, 4, 5, 6, 7], [n(64, op(+, 49, 63)), n(63, op(*, 62, 52)), n(62, w ^ 7), n(61, op(+, 42, 60)), n(60, op(*, 47, 44)), n(59, op(+, 31, 58)), n(58, op(*, 57, 38)), n(57, w ^ 5), n(56, op(+, 11, 55)), n(55, op(*, 24, 21)), n(54, op(+, 49, 53)), n(53, op(*, 50, 52)), n(52, op(+, 34, 51)), n(51, op(*, 47, 36)), n(50, w ^ 3), n(49, op(+, 26, 48)), n(48, op(*, 47, 29)), n(47, w ^ 6), n(46, op(+, 42, 45)), n(45, op(*, 27, 44)), n(44, op(+, 15, 43)), n(43, op(*, 24, 19)), n(42, op(+, 5, 41)), n(41, op(*, 24, 9)), n(40, op(+, 31, 39)), n(39, op(*, 32, 38)), n(38, op(+, 34, 37)), n(37, op(*, 27, 36)), n(36, op(+, 16, 35)), n(35, op(*, 24, 17)), n(34, op(+, 12, 33)), n(33, op(*, 24, 13)), n(32, w ^ 1), n(31, op(+, 26, 30)), n(30, op(*, 27, 29)), n(29, op(+, 6, 28)), n(28, op(*, 24, 7)), n(27, w ^ 2), n(26, op(+, 1, 25)), n(25, op(*, 24, 3)), n(24, w ^ 4), n(23, op(+, 11, 22)), n(22, op(*, 2, 21)), n(21, op(+, 15, 20)), n(20, op(*, 2, 19)), n(19, op(+, 16, 18)), n(18, op(*, 2, 17)), n(17, a(7)), n(16, a(3)), n(15, op(+, 12, 14)), n(14, op(*, 2, 13)), n(13, a(5)), n(12, a(1)), n(11, op(+, 5, 10)), n(10, op(*, 2, 9)), n(9, op(+, 6, 8)), n(8, op(*, 2, 7)), n(7, a(6)), n(6, a(2)), n(5, op(+, 1, 4)), n(4, op(*, 2, 3)), n(3, a(4)), n(2, w ^ 0), n(1, a(0))]).

package/examples/sudoku.pl

@@ -1,4 +1,3 @@
-:- use_module(library(prologue), [between/3]).
 :- use_module(library(lists)).
 
 % A deterministic 9x9 Sudoku solver.
@@ -108,6 +107,7 @@ segment_unused(Cells, StartColumn, Digit) :-
   Digit \= C.
 
 set_cell(Grid, Row, Column, Digit, Result) :-
-  nth0(Row, Grid, Cells),
-  set_nth0(Column, Cells, Digit, UpdatedCells),
-  set_nth0(Row, Grid, UpdatedCells, Result).
+  nth0(Row, Grid, Cells, OtherRows),
+  nth0(Column, Cells, _Old, OtherCells),
+  nth0(Column, UpdatedCells, Digit, OtherCells),
+  nth0(Row, Result, UpdatedCells, OtherRows).

package/index.d.ts

@@ -21,6 +21,8 @@ export interface EyePrologRunOptions {
   analyzeNegation?: boolean;
   /** Restrict parsing and execution to ISO/IEC 13211-1:1995 plus Corrigenda 1-3. */
   isoStrict?: boolean;
+  /** Autoload uniquely mapped predicates from the conservative interop profile. Defaults to true outside strict ISO mode. */
+  autoload?: boolean;
   /** Initial ISO interpretation of double-quoted list notation. Defaults to chars. */
   doubleQuotes?: 'chars' | 'codes' | 'atom';
   ioOptions?: {
@@ -248,6 +250,9 @@ export const standardLibrarySources: ReadonlyMap<string, { filename: string; sou
 export const eyePrologLibraryIndicators: readonly string[];
 export const eyePrologNativeLibraryIndicators: readonly string[];
 export const eyePrologPortableLibraryIndicators: readonly string[];
+export const eyePrologInteropAutoload: Readonly<Record<string, string>>;
+export const eyePrologInteropLibraryIndicators: readonly string[];
+export const eyePrologInteropLibraryModules: readonly string[];
 export class PrologError extends Error {
   formal: string;
   culprit: EyePrologTerm | null;
@@ -326,6 +331,9 @@ declare const eyeprolog: {
   eyePrologLibraryIndicators: typeof eyePrologLibraryIndicators;
   eyePrologNativeLibraryIndicators: typeof eyePrologNativeLibraryIndicators;
   eyePrologPortableLibraryIndicators: typeof eyePrologPortableLibraryIndicators;
+  eyePrologInteropAutoload: typeof eyePrologInteropAutoload;
+  eyePrologInteropLibraryIndicators: typeof eyePrologInteropLibraryIndicators;
+  eyePrologInteropLibraryModules: typeof eyePrologInteropLibraryModules;
   run: typeof run;
   runQuads: typeof runQuads;
   whyProof: typeof whyProof;

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.2.44",
+  "version": "1.3.0",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",
@@ -50,6 +50,7 @@
     "test:eyeprolog": "node test/run-all.mjs",
     "test:conformance": "node test/run-conformance.mjs",
     "test:iso-strict": "node test/run-iso-strict.mjs",
+    "test:interop": "node test/run-interop.mjs",
     "test:wg17": "node test/run-wg17.mjs",
     "test:examples": "node test/run-examples.mjs",
     "test:regression": "node test/run-regression.mjs",

package/src/cli.js

@@ -28,6 +28,8 @@ export async function main(argv) {
     quads: false,
     stats: false,
     isoStrict: false,
+    portable: false,
+    autoload: true,
     version: false,
     warnings: false,
     goals: [],
@@ -51,6 +53,10 @@ export async function main(argv) {
       options.stats = true;
     } else if (!endOptions && arg === '--iso-strict') {
       options.isoStrict = true;
+    } else if (!endOptions && arg === '--portable') {
+      options.portable = true;
+    } else if (!endOptions && arg === '--no-autoload') {
+      options.autoload = false;
     } else if (!endOptions && (arg === '--version' || arg === '-v')) {
       options.version = true;
     } else if (!endOptions && (arg === '--warnings' || arg === '-w')) {
@@ -146,9 +152,16 @@ export async function main(argv) {
   let program = engine.Program.parseSources(sourceParts, {
     sourceMetadata: options.proof || options.isoStrict,
     isoStrict: options.isoStrict,
+    autoload: options.autoload,
+    autoloadGoals: options.goals,
   });
 
-  if (options.warnings) printWarnings(program);
+  const portabilityFailures = program.interopPortabilityWarnings ?? [];
+  if (options.warnings || (options.portable && portabilityFailures.length > 0)) printWarnings(program);
+  if (options.portable && portabilityFailures.length > 0) {
+    process.exitCode = 1;
+    return;
+  }
 
   if (!options.quads || options.goals.length > 0) await runDefault(engine, program, options);
   if (options.quads) {
@@ -263,6 +276,8 @@ Options:
   -s, --stats           Print solver and memory statistics to stderr after execution.
   --iso-strict          Use ISO/IEC 13211-1 core + Corrigenda 1-3 only;
                         reject EyeProlog language extensions and disable automatic tabling.
+  --portable            Enforce the EyeProlog/Trealla/Scryer interop profile.
+  --no-autoload         Disable conservative interop predicate autoloading.
   -v, --version         Show the package version and exit.
   -w, --warnings        Print non-fatal portability warnings to stderr.
   -g, --goal goal       Solve goal and print its ground answers; may be repeated.
@@ -284,6 +299,16 @@ function readStdin() {
 }
 
 function printWarnings(program) {
+  for (const warning of program.interopPortabilityWarnings ?? []) {
+    if (warning.kind === 'library') {
+      process.stderr.write('eyeprolog warning: non-portable library dependency\n');
+      process.stderr.write(`  library(${warning.library}) is outside the EyeProlog/Trealla/Scryer interop profile\n`);
+    } else if (warning.kind === 'predicate') {
+      process.stderr.write('eyeprolog warning: non-portable library predicate\n');
+      process.stderr.write(`  ${warning.indicator} from library(${warning.library}) is outside the interop profile\n`);
+    }
+  }
+
   const errors = program.negationStratificationErrors;
   if (errors.length === 0) return;
 

package/src/index.js

@@ -20,6 +20,9 @@ export {
   eyePrologLibraryIndicators,
   eyePrologNativeLibraryIndicators,
   eyePrologPortableLibraryIndicators,
+  eyePrologInteropAutoload,
+  eyePrologInteropLibraryIndicators,
+  eyePrologInteropLibraryModules,
 } from './standard-library.js';
 export { StreamManager } from './io.js';
 export { runQuads } from './quads.js';
@@ -39,7 +42,12 @@ export function run(source, options = {}) {
   if (source instanceof Program && requestedStrictIso && source.strictIso !== true) {
     throw new Error('strict ISO mode requires a Program parsed with isoStrict: true');
   }
-  const parseOptions = { ...options, sourceMetadata: includeWhy || requestedStrictIso };
+  const requestedGoals = options.goals ?? (options.goal == null ? [] : [options.goal]);
+  const parseOptions = {
+    ...options,
+    sourceMetadata: includeWhy || requestedStrictIso,
+    autoloadGoals: requestedGoals,
+  };
   let program = source instanceof Program ? source : Program.parse(source, parseOptions);
   const strictIso = requestedStrictIso || program.strictIso === true;
   const runOptions = strictIso

package/src/iso.js

@@ -1198,15 +1198,6 @@ function scopeReadTerm(term) {
 
 function parseReadTermText(text, solver) {
   const converted = convertedTermText(text, solver);
-  // A standalone number needs no general term parser or operator tables.
-  // Reuse the same bounded numeric scanner as number_chars/2 so stream reads
-  // and number conversion agree on every accepted numeric token. The stream
-  // scanner has already established that the final full stop is a candidate
-  // terminator; trim only ISO layout immediately before that terminator.
-  const numericText = converted.slice(0, -1).replace(/[\u0009-\u000d\u0020]+$/, '');
-  const numericTerm = parseIsoNumber(numericText);
-  if (numericTerm != null) return numericTerm;
-
   const operatorState = createParserOperatorState(solver.program.operators.values(), false);
   const clauses = parseClauses(converted, {
     sourceMetadata: false,

package/src/lib/lists.pl

@@ -1,15 +1,29 @@
 /** List relations, following the library(lists) organization used by Scryer. */
 
 :- module(lists, [
-    maplist/3,
-    append/3,
     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,
@@ -21,43 +35,122 @@
     slice/4
 ]).
 
+:- meta_predicate(maplist(1, '?')).
 :- meta_predicate(maplist(2, '?', '?')).
+:- meta_predicate(maplist(3, '?', '?', '?')).
+:- meta_predicate(maplist(4, '?', '?', '?', '?')).
+:- meta_predicate(maplist(5, '?', '?', '?', '?', '?')).
+:- meta_predicate(maplist(6, '?', '?', '?', '?', '?', '?')).
+:- meta_predicate(maplist(7, '?', '?', '?', '?', '?', '?', '?')).
+:- meta_predicate(foldl(3, '?', '?', '?')).
+:- meta_predicate(foldl(4, '?', '?', '?', '?')).
+:- meta_predicate(foldl(5, '?', '?', '?', '?', '?')).
 :- meta_predicate(countall(0, '?')).
 
 % Common pure-Prolog library predicates for EyeProlog.
 %
-% Load this module explicitly with use_module(library(lists)). The module
-% boundary keeps these widespread names separate from same-named predicates in
-% other modules.
+% The common Trealla/Scryer-facing surface can be imported explicitly with
+% use_module(library(lists)); EyeProlog may also autoload those common
+% indicators when an otherwise undefined unqualified call is encountered.
+% EyeProlog-specific helpers remain explicit and are diagnosed by --warnings.
+
+maplist(_, []).
+maplist(Closure, [A|As]) :-
+    call(Closure, A),
+    maplist(Closure, As).
 
 maplist(_, [], []).
 maplist(Closure, [A|As], [B|Bs]) :-
     call(Closure, A, B),
     maplist(Closure, As, Bs).
 
+maplist(_, [], [], []).
+maplist(Closure, [A|As], [B|Bs], [C|Cs]) :-
+    call(Closure, A, B, C),
+    maplist(Closure, As, Bs, Cs).
+
+maplist(_, [], [], [], []).
+maplist(Closure, [A|As], [B|Bs], [C|Cs], [D|Ds]) :-
+    call(Closure, A, B, C, D),
+    maplist(Closure, As, Bs, Cs, Ds).
+
+maplist(_, [], [], [], [], []).
+maplist(Closure, [A|As], [B|Bs], [C|Cs], [D|Ds], [E|Es]) :-
+    call(Closure, A, B, C, D, E),
+    maplist(Closure, As, Bs, Cs, Ds, Es).
+
+maplist(_, [], [], [], [], [], []).
+maplist(Closure, [A|As], [B|Bs], [C|Cs], [D|Ds], [E|Es], [F|Fs]) :-
+    call(Closure, A, B, C, D, E, F),
+    maplist(Closure, As, Bs, Cs, Ds, Es, Fs).
+
+maplist(_, [], [], [], [], [], [], []).
+maplist(Closure, [A|As], [B|Bs], [C|Cs], [D|Ds], [E|Es], [F|Fs], [G|Gs]) :-
+    call(Closure, A, B, C, D, E, F, G),
+    maplist(Closure, As, Bs, Cs, Ds, Es, Fs, Gs).
+
+append([], []).
+append([Xs|Xss], Ys) :-
+    append(Xs, Rest, Ys),
+    append(Xss, Rest).
+
 append([], Ys, Ys).
 append([X|Xs], Ys, [X|Zs]) :- append(Xs, Ys, Zs).
 
 member(X, [X|_]).
 member(X, [_|Xs]) :- member(X, Xs).
 
+memberchk(X, Xs) :- member(X, Xs), !.
+
 select(X, [X|Xs], Xs).
 select(X, [Y|Ys], [Y|Zs]) :- select(X, Ys, Zs).
 
 last([X], X).
 last([_|Xs], X) :- last(Xs, X).
 
-nth0(0, [X|_], X).
-nth0(N, [_|Xs], X) :- var(N), nth0(N0, Xs, X), N is N0 + 1.
-nth0(N, [_|Xs], X) :- nonvar(N), N > 0, N1 is N - 1, nth0(N1, Xs, X).
+same_length([], []).
+same_length([_|Xs], [_|Ys]) :- same_length(Xs, Ys).
+
+nth0(N, List, Elem) :- nth0(N, List, Elem, _).
+
+nth0(0, [Elem|Rest], Elem, Rest).
+nth0(N, [X|Xs], Elem, [X|Rest]) :-
+    var(N),
+    nth0(N0, Xs, Elem, Rest),
+    N is N0 + 1.
+nth0(N, [X|Xs], Elem, [X|Rest]) :-
+    nonvar(N),
+    N > 0,
+    N0 is N - 1,
+    nth0(N0, Xs, Elem, Rest).
 
-nth1(N, List, X) :- nth0(N0, List, X), N is N0 + 1.
+nth1(N, List, Elem) :- nth1(N, List, Elem, _).
+
+nth1(N, List, Elem, Rest) :-
+    N \== 0,
+    nth0(N, [_|List], Elem, [_|Rest]),
+    N \== 0.
 
 reverse(List, Reversed) :- lists__reverse(List, [], Reversed).
 
 length(List, Length) :- nonvar(List), lists__length_count(List, 0, Length).
 length(List, Length) :- var(List), integer(Length), Length >= 0, lists__length_make(Length, List).
 
+foldl(_, [], Acc, Acc).
+foldl(Closure, [A|As], Acc0, Acc) :-
+    call(Closure, A, Acc0, Acc1),
+    foldl(Closure, As, Acc1, Acc).
+
+foldl(_, [], [], Acc, Acc).
+foldl(Closure, [A|As], [B|Bs], Acc0, Acc) :-
+    call(Closure, A, B, Acc0, Acc1),
+    foldl(Closure, As, Bs, Acc1, Acc).
+
+foldl(_, [], [], [], Acc, Acc).
+foldl(Closure, [A|As], [B|Bs], [C|Cs], Acc0, Acc) :-
+    call(Closure, A, B, C, Acc0, Acc1),
+    foldl(Closure, As, Bs, Cs, Acc1, Acc).
+
 sum_list(List, Sum) :- lists__sum_list(List, 0, Sum).
 
 min_list([X|Xs], Min) :- lists__min_list(Xs, X, Min).

package/src/program.js

@@ -10,11 +10,17 @@ import {
   createParserOperatorState,
   parseClauses,
   parseClausesInto,
+  parseGoalText,
   tryParseClausesFastInto,
 } from './parser.js';
 import { PrologError, getStrictIsoRegistry } from './iso.js';
 import { currentWorkingDirectory, fs, path } from './platform.js';
-import { standardLibrarySources } from './standard-library.js';
+import {
+  standardLibrarySources,
+  eyePrologInteropAutoload,
+  eyePrologInteropLibraryIndicators,
+  eyePrologInteropLibraryModules,
+} from './standard-library.js';
 import { expandDcgRuleClause } from './dcg.js';
 
 const DEFER_PROGRAM_BUILD = Symbol('deferProgramBuild');
@@ -102,6 +108,9 @@ export class Program {
     this.modules = new Map([['user', { name: 'user', exports: new Map(), filename: '<input>' }]]);
     this.moduleImports = new Map();
     this.moduleMetaPredicates = new Map();
+    this.autoloadedPredicates = [];
+    this.libraryImports = [];
+    this.interopPortabilityWarnings = [];
     this.dynamicPredicates = new Set();
     this.strictIso = options.isoStrict === true;
     this.operators = new Map();
@@ -677,6 +686,19 @@ function loadSourcesIntoBuilder(builder, sources, options, fast) {
       const context = { module: 'user' };
       if (!loadSourceIntoBuilder(builder, text, item.options, ensured, loadedModules, fast, context)) return false;
     }
+    const autoloadGoals = parseInteropGoalInputs(options.autoloadGoals, {
+      ...options,
+      operatorState,
+      parserFlagState,
+    }, builder.program);
+    if (options.isoStrict !== true && options.autoload !== false) {
+      autoloadInteropDependencies(builder, {
+        ...options,
+        operatorState,
+        parserFlagState,
+      }, ensured, loadedModules, autoloadGoals);
+    }
+    analyzeInteropPortability(builder.program, autoloadGoals);
     builder.program.doubleQuotes = parserFlagState.doubleQuotes;
     return true;
   } catch (error) {
@@ -685,6 +707,208 @@ function loadSourcesIntoBuilder(builder, sources, options, fast) {
   }
 }
 
+
+const interopIndicatorSet = new Set(eyePrologInteropLibraryIndicators);
+const interopLibraryModuleSet = new Set(eyePrologInteropLibraryModules);
+
+function libraryDesignationName(designation) {
+  return designation?.type === COMPOUND && designation.name === 'library' && designation.arity === 1 &&
+    designation.args[0]?.type === ATOM
+    ? designation.args[0].name
+    : null;
+}
+
+function bundledLibraryModule(program, module) {
+  return module !== 'user' && program.modules.get(module)?.filename?.startsWith('src/lib/');
+}
+
+function groupDependencies(group) {
+  const dependencies = [];
+  for (const clause of group.clauses) {
+    if (isCompactBinaryClause(clause)) {
+      if (clause.bodyName != null) {
+        dependencies.push({
+          key: `${clause.bodyName}/2`,
+          name: clause.bodyName,
+          arity: 2,
+          module: clause.module ?? group.module,
+        });
+      }
+      continue;
+    }
+    for (const goal of clause.body) {
+      dependencies.push(...collectGoalDependencies(goal, false, true));
+    }
+  }
+  return dependencies;
+}
+
+function parseInteropGoalInputs(inputs, options, program) {
+  if (inputs == null) return [];
+  const values = Array.isArray(inputs) ? inputs : [inputs];
+  return values.filter((value) => value != null).map((value) => {
+    if (typeof value !== 'string') return value;
+    return parseGoalText(value, {
+      doubleQuotes: options.parserFlagState?.doubleQuotes ?? options.doubleQuotes ?? program.doubleQuotes ?? 'chars',
+      operatorDefinitions: [...program.operators.values()],
+      isoStrict: options.isoStrict === true,
+    });
+  });
+}
+
+function extraGoalDependencies(goals) {
+  const dependencies = [];
+  for (const goal of goals) dependencies.push(...collectGoalDependencies(goal, false, true));
+  return dependencies;
+}
+
+function interopAutoloadRequests(program, extraGoals = []) {
+  const requests = new Map();
+  for (const group of program.groups.values()) {
+    if (bundledLibraryModule(program, group.module)) continue;
+    for (const dependency of groupDependencies(group)) {
+      const targetModule = dependency.module ?? group.module;
+      if (program.findGroup(dependency.name, dependency.arity, targetModule)) continue;
+      const library = eyePrologInteropAutoload[dependency.key];
+      if (library == null) continue;
+      const requestKey = `${targetModule}\u0000${dependency.key}`;
+      requests.set(requestKey, {
+        targetModule,
+        library,
+        name: dependency.name,
+        arity: dependency.arity,
+        key: dependency.key,
+      });
+    }
+  }
+  for (const goal of program.initializations) {
+    for (const dependency of collectGoalDependencies(goal, false, true)) {
+      const targetModule = dependency.module ?? 'user';
+      if (program.findGroup(dependency.name, dependency.arity, targetModule)) continue;
+      const library = eyePrologInteropAutoload[dependency.key];
+      if (library == null) continue;
+      const requestKey = `${targetModule}\u0000${dependency.key}`;
+      requests.set(requestKey, {
+        targetModule,
+        library,
+        name: dependency.name,
+        arity: dependency.arity,
+        key: dependency.key,
+      });
+    }
+  }
+  for (const dependency of extraGoalDependencies(extraGoals)) {
+    const targetModule = dependency.module ?? 'user';
+    if (program.findGroup(dependency.name, dependency.arity, targetModule)) continue;
+    const library = eyePrologInteropAutoload[dependency.key];
+    if (library == null) continue;
+    const requestKey = `${targetModule}\u0000${dependency.key}`;
+    requests.set(requestKey, {
+      targetModule,
+      library,
+      name: dependency.name,
+      arity: dependency.arity,
+      key: dependency.key,
+    });
+  }
+  return [...requests.values()];
+}
+
+function autoloadInteropDependencies(builder, options, ensured, loadedModules, extraGoals = []) {
+  const program = builder.program;
+  while (true) {
+    const requests = interopAutoloadRequests(program, extraGoals);
+    if (requests.length === 0) return;
+    let changed = false;
+    for (const request of requests) {
+      if (program.findGroup(request.name, request.arity, request.targetModule)) continue;
+      if (!loadedModules.has(request.library)) {
+        const designation = compound('library', [atom(request.library)]);
+        const loaded = readModuleSource(designation, options);
+        const childContext = { module: loaded.name };
+        // Bundled library sources are small and directive-heavy.  Parse them
+        // with the general parser even when the user source took the compact
+        // fast path; this avoids rebuilding otherwise-fast user programs.
+        if (!loadSourceIntoBuilder(
+          builder, loaded.text, loaded.options, ensured, loadedModules, false, childContext,
+        )) {
+          throw new Error(`could not autoload library(${request.library})`);
+        }
+      }
+      program.importModule(request.targetModule, request.library, [request]);
+      program.autoloadedPredicates.push({
+        targetModule: request.targetModule,
+        library: request.library,
+        indicator: request.key,
+      });
+      changed = true;
+    }
+    if (!changed) return;
+  }
+}
+
+function analyzeInteropPortability(program, extraGoals = []) {
+  const warnings = new Map();
+  const nonInteropImports = new Map();
+  for (const entry of program.libraryImports) {
+    if (bundledLibraryModule(program, entry.targetModule)) continue;
+    if (!interopLibraryModuleSet.has(entry.library)) {
+      warnings.set(`library:${entry.targetModule}:${entry.library}`, {
+        kind: 'library',
+        library: entry.library,
+        targetModule: entry.targetModule,
+      });
+      const libraries = nonInteropImports.get(entry.targetModule) ?? new Set();
+      libraries.add(entry.library);
+      nonInteropImports.set(entry.targetModule, libraries);
+      continue;
+    }
+    if (entry.imports != null) {
+      for (const indicator of entry.imports) {
+        if (interopIndicatorSet.has(indicator.key)) continue;
+        warnings.set(`predicate:${entry.targetModule}:${entry.library}:${indicator.key}`, {
+          kind: 'predicate',
+          library: entry.library,
+          indicator: indicator.key,
+          targetModule: entry.targetModule,
+        });
+      }
+    }
+  }
+
+  for (const group of program.groups.values()) {
+    if (bundledLibraryModule(program, group.module)) continue;
+    for (const dependency of groupDependencies(group)) {
+      const targetModule = dependency.module ?? group.module;
+      const resolved = program.findGroup(dependency.name, dependency.arity, targetModule);
+      if (!resolved || !bundledLibraryModule(program, resolved.module)) continue;
+      if (interopIndicatorSet.has(dependency.key)) continue;
+      if (nonInteropImports.get(targetModule)?.has(resolved.module)) continue;
+      warnings.set(`predicate:${targetModule}:${resolved.module}:${dependency.key}`, {
+        kind: 'predicate',
+        library: resolved.module,
+        indicator: dependency.key,
+        targetModule,
+      });
+    }
+  }
+
+  for (const dependency of extraGoalDependencies(extraGoals)) {
+    const targetModule = dependency.module ?? 'user';
+    const resolved = program.findGroup(dependency.name, dependency.arity, targetModule);
+    if (!resolved || !bundledLibraryModule(program, resolved.module)) continue;
+    if (interopIndicatorSet.has(dependency.key)) continue;
+    if (nonInteropImports.get(targetModule)?.has(resolved.module)) continue;
+    warnings.set(`predicate:${targetModule}:${resolved.module}:${dependency.key}`, {
+      kind: 'predicate',
+      library: resolved.module,
+      indicator: dependency.key,
+      targetModule,
+    });
+  }
+  program.interopPortabilityWarnings = [...warnings.values()];
+}
+
 function sourceOptionsFor(source, options) {
   if (typeof source === 'string') return options;
   return {
@@ -736,6 +960,14 @@ function loadSourceIntoBuilder(builder, source, options, ensured, loadedModules,
       flush();
       clause.module = context.module;
       builder.addClauses([clause]);
+      const libraryName = libraryDesignationName(use.designation);
+      if (libraryName != null) {
+        builder.program.libraryImports.push({
+          targetModule: context.module,
+          library: libraryName,
+          imports: use.imports == null ? null : use.imports.map((indicator) => ({ ...indicator })),
+        });
+      }
       const loaded = readModuleSource(use.designation, options);
       if (!loadedModules.has(loaded.name)) {
         const childContext = { module: loaded.name };

package/src/standard-library.js

@@ -1,7 +1,7 @@
 // ISO/IEC 13211-2 module sources shipped with EyeProlog.
-// The sources are registered here so library(Name) works in Node and browsers;
-// unlike the former autoloader, no clauses are added unless use_module/1 or
-// use_module/2 requests their module.
+// The sources are registered here so library(Name) works in Node and browsers.
+// Modules are loaded on demand by explicit use_module/1-2 or by the conservative
+// source-level interop autoloader declared below.
 import { PrologError, createDefaultRegistry, eyePrologLibraryBuiltins } from './iso.js';
 import { clpzBuiltins } from './clpz.js';
 import { fs, isNode, memoryStatistics } from './platform.js';
@@ -62,8 +62,8 @@ export const eyePrologPortableLibraryIndicators = Object.freeze([
   'maplist/6', 'maplist/7', 'maplist/8', 'between/3',
   'smallest_divisor_from/3', 'random/3', 'matches/3', 'split/3',
   'replace/4', 'lowercase/2', 'uppercase/2', 'trim/2', 'number_string/2',
-  'atom_string/2', 'term_string/2', 'append/3', 'string_concat/3', 'contains/2',
-  'matches/2', 'join/3', 'substring/4', 'member/2', 'select/3', 'last/2',
+  'atom_string/2', 'term_string/2', 'append/2', 'append/3', 'string_concat/3', 'contains/2',
+  'matches/2', 'join/3', 'substring/4', 'member/2', 'memberchk/2', 'select/3', 'last/2', 'same_length/2',
   'nth0/3', 'nth0/4', 'nth1/3', 'nth1/4', 'set_nth0/4', 'take/3', 'drop/3', 'slice/4', 'reverse/2',
   'length/2', 'sum_list/2', 'min_list/2', 'max_list/2', 'list_to_set/2',
   'succ/2', 'foldl/4', 'foldl/5', 'foldl/6',
@@ -74,6 +74,57 @@ export const eyePrologLibraryIndicators = Object.freeze([
   ...eyePrologNativeLibraryIndicators,
 ]);
 
+
+// Conservative cross-implementation profile.  These predicate indicators are
+// intentionally limited to interfaces that EyeProlog wants to keep source-
+// compatible with the Trealla/Scryer ecosystem.  The value is the canonical
+// EyeProlog library used when an otherwise undefined call is autoloaded.
+//
+// This is deliberately separate from eyePrologPortableLibraryIndicators:
+// "portable" there means implemented in Prolog rather than as a host builtin;
+// this table means interoperable source-level API.
+export const eyePrologInteropAutoload = Object.freeze({
+  'member/2': 'lists',
+  'memberchk/2': 'lists',
+  'select/3': 'lists',
+  'append/2': 'lists',
+  'append/3': 'lists',
+  'last/2': 'lists',
+  'same_length/2': 'lists',
+  'nth0/3': 'lists',
+  'nth0/4': 'lists',
+  'nth1/3': 'lists',
+  'nth1/4': 'lists',
+  'reverse/2': 'lists',
+  'length/2': 'lists',
+  'maplist/2': 'lists',
+  'maplist/3': 'lists',
+  'maplist/4': 'lists',
+  'maplist/5': 'lists',
+  'maplist/6': 'lists',
+  'maplist/7': 'lists',
+  'maplist/8': 'lists',
+  'foldl/4': 'lists',
+  'foldl/5': 'lists',
+  'foldl/6': 'lists',
+  'sum_list/2': 'lists',
+  'list_to_set/2': 'lists',
+  // 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
+  // implementation-specific library.
+  'between/3': 'prologue',
+});
+
+export const eyePrologInteropLibraryIndicators = Object.freeze(
+  Object.keys(eyePrologInteropAutoload),
+);
+
+// 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']);
+
 function runtimeStatistics(solver) {
   return { ...solver.stats, ...memoryStatistics() };
 }

package/test/run-interop.mjs

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+// Cross-implementation smoke tests for source-level Prolog interoperability.
+//
+// By default this runner requires Trealla (`tpl`) and Scryer (`scryer-prolog`)
+// to be installed.  Pass --allow-missing for local development when only the
+// EyeProlog leg is available.
+import path from 'node:path';
+import process from 'node:process';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const allowMissing = process.argv.includes('--allow-missing');
+const sudoku = path.join(root, 'examples', 'sudoku.pl');
+const goal = 'sudoku_solution(S), write(S), nl, fail; halt';
+const expected = '[[5,3,4,6,7,8,9,1,2],[6,7,2,1,9,5,3,4,8],[1,9,8,3,4,2,5,6,7],[8,5,9,7,6,1,4,2,3],[4,2,6,8,5,3,7,9,1],[7,1,3,9,2,4,8,5,6],[9,6,1,5,3,7,2,8,4],[2,8,7,4,1,9,6,3,5],[3,4,5,2,8,6,1,7,9]]';
+
+const engines = [
+  {
+    name: 'EyeProlog',
+    command: process.execPath,
+    args: [path.join(root, 'bin', 'eyeprolog.js'), '--portable', '-g', goal, sudoku],
+  },
+  {
+    name: 'Trealla',
+    command: process.env.TPL ?? 'tpl',
+    args: ['-q', '-g', goal, sudoku],
+  },
+  {
+    name: 'Scryer',
+    command: process.env.SCRYER_PROLOG ?? 'scryer-prolog',
+    args: ['-f', '-g', goal, sudoku],
+  },
+];
+
+let failed = false;
+let executed = 0;
+for (const engine of engines) {
+  const result = spawnSync(engine.command, engine.args, {
+    cwd: root,
+    encoding: 'utf8',
+    timeout: 120000,
+  });
+  if (result.error?.code === 'ENOENT') {
+    if (allowMissing && engine.name !== 'EyeProlog') {
+      console.log(`SKIP ${engine.name}: ${engine.command} not installed`);
+      continue;
+    }
+    console.error(`FAIL ${engine.name}: ${engine.command} not installed`);
+    failed = true;
+    continue;
+  }
+  executed++;
+  if (result.error) {
+    console.error(`FAIL ${engine.name}: ${result.error.message}`);
+    failed = true;
+    continue;
+  }
+  if (result.status !== 0) {
+    console.error(`FAIL ${engine.name}: exit ${result.status}`);
+    if (result.stderr) console.error(result.stderr.trim());
+    failed = true;
+    continue;
+  }
+  const lines = String(result.stdout ?? '').split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  if (!lines.includes(expected)) {
+    console.error(`FAIL ${engine.name}: Sudoku output mismatch`);
+    console.error(`stdout: ${JSON.stringify(result.stdout)}`);
+    if (result.stderr) console.error(`stderr: ${result.stderr.trim()}`);
+    failed = true;
+    continue;
+  }
+  console.log(`OK ${engine.name}: portable Sudoku`);
+}
+
+if (failed) process.exitCode = 1;
+else console.log(`OK ${executed}/${allowMissing ? engines.length : executed} available interop engines passed`);

package/test/run-regression.mjs

@@ -23,6 +23,9 @@ import {
   eyePrologLibraryIndicators,
   eyePrologNativeLibraryIndicators,
   eyePrologPortableLibraryIndicators,
+  eyePrologInteropAutoload,
+  eyePrologInteropLibraryIndicators,
+  eyePrologInteropLibraryModules,
   atom,
   compound,
   listFromItems,
@@ -692,108 +695,6 @@ c4 ?- call((!;1)).
         }
       },
     },
-    {
-      name: 'read/2 and number_chars/2 agree on bounded numeric syntax (issue #29)',
-      run: () => {
-        const registry = createDefaultRegistry();
-        const numberChars = registry.get('number_chars', 2).handler;
-        const read = registry.get('read', 2).handler;
-        const solver = new Solver(Program.parse(''), { registry, ioOptions: { input: '' } });
-        const stream = solver.io.resolve(0);
-        const streamTerm = compound('$stream', [numberTerm('0')]);
-        const alphabet = ['0', '1', '2', '7', '8', '9', 'a', 'f', 'x', 'e', 'E', '+', '-', '.', "'", '\\', ' '];
-        let checked = 0;
-        let accepted = 0;
-
-        const visit = (prefix, remaining) => {
-          if (remaining === 0) {
-            checked++;
-            const converted = variable('Converted');
-            const conversionGoal = compound('number_chars', [
-              converted,
-              listFromItems(Array.from(prefix, atom)),
-            ]);
-            let conversion;
-            try {
-              conversion = numberChars({ goal: conversionGoal, env: new Env() }).next();
-            } catch (_) {
-              return;
-            }
-            if (conversion.done) return;
-            accepted++;
-            const expected = copyResolved(converted, conversion.value);
-
-            stream.content = `${prefix}. `;
-            stream.position = 0;
-            stream.pastEnd = false;
-            const readValue = variable('ReadValue');
-            const readGoal = compound('read', [streamTerm, readValue]);
-            const answer = read({ solver, goal: readGoal, env: new Env() }).next();
-            if (answer.done) throw new Error(`read/2 rejected number_chars/2 spelling ${JSON.stringify(prefix)}`);
-            const actual = copyResolved(readValue, answer.value);
-            assertEqual(actual.type, 'number', `read/2 type for ${JSON.stringify(prefix)}`);
-            assertEqual(actual.name, expected.name, `read/2 value for ${JSON.stringify(prefix)}`);
-            return;
-          }
-          for (const character of alphabet) visit(prefix + character, remaining - 1);
-        };
-
-        for (let length = 1; length <= 4; length++) visit('', length);
-        assertEqual(checked, 88740, 'bounded numeric spellings checked');
-        if (accepted < 1000) throw new Error(`unexpectedly small accepted numeric corpus: ${accepted}`);
-      },
-    },
-    {
-      name: 'number_chars/2 to read/2 cross-check stays bounded under a small heap (issue #29)',
-      run: () => {
-        const engineUrl = new URL('../src/index.js', import.meta.url).href;
-        const script = `
-          import {
-            Program, Solver, Env, atom, compound, variable, listFromItems,
-            numberTerm, copyResolved, createDefaultRegistry,
-          } from ${JSON.stringify(engineUrl)};
-          const registry = createDefaultRegistry();
-          const numberChars = registry.get('number_chars', 2).handler;
-          const read = registry.get('read', 2).handler;
-          const solver = new Solver(Program.parse(''), { registry, ioOptions: { input: '' } });
-          const stream = solver.io.resolve(0);
-          const streamTerm = compound('$stream', [numberTerm('0')]);
-          for (let i = 0; i < 250000; i++) {
-            const text = String(i);
-            const converted = variable('Converted');
-            const conversionGoal = compound('number_chars', [
-              converted,
-              listFromItems(Array.from(text, atom)),
-            ]);
-            const conversion = numberChars({ goal: conversionGoal, env: new Env() }).next();
-            if (conversion.done) throw new Error('number_chars/2 failed at ' + i);
-            const expected = copyResolved(converted, conversion.value);
-
-            stream.content = text + '. ';
-            stream.position = 0;
-            stream.pastEnd = false;
-            const readValue = variable('ReadValue');
-            const readGoal = compound('read', [streamTerm, readValue]);
-            const answer = read({ solver, goal: readGoal, env: new Env() }).next();
-            if (answer.done) throw new Error('read/2 failed at ' + i);
-            const actual = copyResolved(readValue, answer.value);
-            if (actual.type !== 'number' || actual.name !== expected.name) {
-              throw new Error('number mismatch at ' + i + ': ' + actual.name + ' != ' + expected.name);
-            }
-          }
-          process.stdout.write('250000');
-        `;
-        const result = spawnSync(process.execPath, [
-          '--max-old-space-size=32',
-          '--input-type=module',
-          '--eval',
-          script,
-        ], { cwd: packageRoot, encoding: 'utf8', timeout: 30000 });
-        if (result.error) throw result.error;
-        assertEqual(result.status, 0, `bounded-heap child status; stderr=${result.stderr}`);
-        assertEqual(result.stdout, '250000', 'number_chars/read cross-check count');
-      },
-    },
     {
       name: 'number syntax and number_chars normalize floating-point negative zero',
       run: () => {
@@ -1270,6 +1171,8 @@ c4 ?- call((!;1)).
         assertIncludes(result.stdout, '-p, --proof', 'stdout');
         assertIncludes(result.stdout, '-q, --quads', 'stdout');
         assertIncludes(result.stdout, '-s, --stats', 'stdout');
+        assertIncludes(result.stdout, '--portable', 'stdout');
+        assertIncludes(result.stdout, '--no-autoload', 'stdout');
         assertIncludes(result.stdout, '-v, --version', 'stdout');
         assertIncludes(result.stdout, '-w, --warnings', 'stdout');
         assertIncludes(result.stdout, '-v, --version         Show the package version and exit.\n  -w, --warnings        Print non-fatal portability warnings to stderr.', 'stdout');
@@ -2107,6 +2010,125 @@ c4 ?- call((!;1)).
         assertIncludes(result.stderr, 'existence_error(procedure)', 'stderr');
       },
     },
+    {
+      name: 'portable library predicates autoload without use_module directives',
+      run: () => {
+        const input = '%% goal: answer(X)\nanswer(X) :- member(X, [a,b]).\n';
+        const result = runCli(['-'], { input });
+        assertEqual(result.status, 0, 'exit status');
+        assertEqual(result.stdout, 'answer(a).\nanswer(b).\n', 'stdout');
+        assertEqual(result.stderr, '', 'stderr');
+      },
+    },
+    {
+      name: 'between/3 autoload removes the EyeProlog-specific prologue dependency',
+      run: () => {
+        const input = '%% goal: answer(X)\nanswer(X) :- between(1, 3, X).\n';
+        const result = runCli(['-'], { input });
+        assertEqual(result.status, 0, 'exit status');
+        assertEqual(result.stdout, 'answer(1).\nanswer(2).\nanswer(3).\n', 'stdout');
+        assertEqual(result.stderr, '', 'stderr');
+      },
+    },
+    {
+      name: 'strict ISO mode disables interop autoloading',
+      run: () => {
+        const input = '%% goal: answer(X)\nanswer(X) :- member(X, [a,b]).\n';
+        const result = runCli(['--iso-strict', '-'], { input });
+        assertEqual(result.status, 1, 'exit status');
+        assertIncludes(result.stderr, 'existence_error(procedure)', 'stderr');
+        assertIncludes(result.stderr, '/(member, 2)', 'stderr');
+      },
+    },
+    {
+      name: 'CLI top-level goals participate in interop autoloading',
+      run: () => {
+        const result = runCli(['-g', 'member(X,[a,b])', '-'], { input: '' });
+        assertEqual(result.status, 0, 'exit status');
+        assertEqual(result.stdout, 'member(a, "ab").\nmember(b, "ab").\n', 'stdout');
+        assertEqual(result.stderr, '', 'stderr');
+      },
+    },
+    {
+      name: '--no-autoload also applies to CLI top-level goals',
+      run: () => {
+        const result = runCli(['--no-autoload', '-g', 'member(X,[a])', '-'], { input: '' });
+        assertEqual(result.status, 1, 'exit status');
+        assertIncludes(result.stderr, 'existence_error(procedure)', 'stderr');
+        assertIncludes(result.stderr, '/(member, 2)', 'stderr');
+      },
+    },
+    {
+      name: '--portable checks non-portable predicates used only by top-level goals',
+      run: () => {
+        const input = ':- use_module(library(lists)).\n';
+        const result = runCli(['--portable', '-g', 'set_nth0(0,[a],b,X)', '-'], { input });
+        assertEqual(result.status, 1, 'exit status');
+        assertEqual(result.stdout, '', 'stdout');
+        assertIncludes(result.stderr, 'non-portable library predicate', 'stderr');
+        assertIncludes(result.stderr, 'set_nth0/4', 'stderr');
+      },
+    },
+    {
+      name: '--portable accepts the common interop profile',
+      run: () => {
+        const input = ':- use_module(library(lists)).\n%% goal: answer(X)\nanswer(X) :- member(X, [a]).\n';
+        const result = runCli(['--portable', '-'], { input });
+        assertEqual(result.status, 0, 'exit status');
+        assertEqual(result.stdout, 'answer(a).\n', 'stdout');
+        assertEqual(result.stderr, '', 'stderr');
+      },
+    },
+    {
+      name: '--portable rejects implementation-specific library dependencies',
+      run: () => {
+        const input = ':- use_module(library(prologue), [between/3]).\n%% goal: answer\nanswer :- between(1, 1, _).\n';
+        const result = runCli(['--portable', '-'], { input });
+        assertEqual(result.status, 1, 'exit status');
+        assertEqual(result.stdout, '', 'stdout');
+        assertIncludes(result.stderr, 'non-portable library dependency', 'stderr');
+      },
+    },
+    {
+      name: '--no-autoload exposes unresolved portable dependencies',
+      run: () => {
+        const input = '%% goal: answer(X)\nanswer(X) :- member(X, [a]).\n';
+        const result = runCli(['--no-autoload', '-'], { input });
+        assertEqual(result.status, 1, 'exit status');
+        assertIncludes(result.stderr, 'existence_error(procedure)', 'stderr');
+        assertIncludes(result.stderr, '/(member, 2)', 'stderr');
+      },
+    },
+    {
+      name: '--warnings flags explicit library(prologue) dependencies',
+      run: () => {
+        const input = ':- use_module(library(prologue), [between/3]).\n%% goal: answer\nanswer :- between(1, 1, _).\n';
+        const result = runCli(['--warnings', '-'], { input });
+        assertEqual(result.status, 0, 'exit status');
+        assertIncludes(result.stderr, 'eyeprolog warning: non-portable library dependency\n', 'stderr');
+        assertIncludes(result.stderr, 'library(prologue) is outside the EyeProlog/Trealla/Scryer interop profile', 'stderr');
+      },
+    },
+    {
+      name: '--warnings flags EyeProlog-only predicates from library(lists)',
+      run: () => {
+        const input = ':- use_module(library(lists)).\n%% goal: answer(X)\nanswer(X) :- set_nth0(0, [a], b, X).\n';
+        const result = runCli(['--warnings', '-'], { input });
+        assertEqual(result.status, 0, 'exit status');
+        assertIncludes(result.stderr, 'eyeprolog warning: non-portable library predicate\n', 'stderr');
+        assertIncludes(result.stderr, 'set_nth0/4 from library(lists) is outside the interop profile', 'stderr');
+      },
+    },
+    {
+      name: '--warnings stays quiet for the common library(lists) profile',
+      run: () => {
+        const input = ':- use_module(library(lists)).\n%% goal: answer(X)\nanswer(X) :- member(X, [a]).\n';
+        const result = runCli(['--warnings', '-'], { input });
+        assertEqual(result.status, 0, 'exit status');
+        assertEqual(result.stdout, 'answer(a).\n', 'stdout');
+        assertEqual(result.stderr, '', 'stderr');
+      },
+    },
     {
       name: '--warnings prints unstratified negation diagnostics without failing',
       run: () => {
@@ -3055,6 +3077,71 @@ open(X) :- candidate(X), \\+ closed(X).
         assertEqual(answers.join('\n'), 'answer("ab")', 'answers');
       },
     },
+    {
+      name: 'library(lists) exposes the Trealla/Scryer common surface',
+      run: () => {
+        const program = Program.parse(`:- use_module(library(lists)).
+identity(X, X).
+pair(A, B, A-B).
+step(X, A0, A) :- A is A0 + X.
+check(A, B, C, D, E, F) :-
+  append([[a],[b]], A),
+  memberchk(a, A),
+  same_length(A, [_,_]),
+  nth0(1, A, b, B),
+  maplist(identity, A, C),
+  maplist(pair, A, [1,2], D),
+  foldl(step, [1,2,3], 0, E),
+  nth1(2, A, b, F).
+`);
+        assertEqual(program.findGroup('append', 2)?.module, 'lists', 'append/2 import');
+        assertEqual(program.findGroup('memberchk', 2)?.module, 'lists', 'memberchk/2 import');
+        assertEqual(program.findGroup('same_length', 2)?.module, 'lists', 'same_length/2 import');
+        assertEqual(program.findGroup('nth0', 4)?.module, 'lists', 'nth0/4 import');
+        assertEqual(program.findGroup('maplist', 2)?.module, 'lists', 'maplist/2 import');
+        assertEqual(program.findGroup('maplist', 3)?.module, 'lists', 'maplist/3 import');
+        assertEqual(program.findGroup('foldl', 4)?.module, 'lists', 'foldl/4 import');
+        const result = run(program, { goal: 'check(A,B,C,D,E,F)' });
+        assertIncludes(result.stdout, 'check("ab", "a", "ab", [a - 1, b - 2], 6, "a").\n', 'stdout');
+      },
+    },
+    {
+      name: 'autoload metadata records canonical interop imports',
+      run: () => {
+        const program = Program.parse('answer(X) :- member(X, [a]), between(1, 1, _).\n');
+        assertEqual(program.autoloadedPredicates.length, 2, 'autoloaded predicate count');
+        assertEqual(program.autoloadedPredicates.map((entry) => `${entry.indicator}:${entry.library}`).sort().join(','),
+          'between/3:prologue,member/2:lists', 'autoload mapping');
+        assertEqual(program.interopPortabilityWarnings.length, 0, 'autoloaded portable calls are warning-free');
+      },
+    },
+    {
+      name: 'JavaScript run top-level goals participate in interop autoloading',
+      run: () => {
+        const result = runEyeProlog('', { goal: 'member(X,[a,b])' });
+        assertEqual(result.stdout, 'member(a, "ab").\nmember(b, "ab").\n', 'stdout');
+      },
+    },
+    {
+      name: 'JavaScript run can disable top-level goal autoloading',
+      run: () => {
+        let error = null;
+        try {
+          runEyeProlog('', { goal: 'member(X,[a])', autoload: false });
+        } catch (caught) {
+          error = caught;
+        }
+        assertIncludes(error?.message ?? '', 'existence_error(procedure)', 'error');
+      },
+    },
+    {
+      name: 'autoload can be disabled explicitly in the JavaScript API',
+      run: () => {
+        const program = Program.parse('answer(X) :- member(X, [a]).\n', { autoload: false });
+        assertEqual(program.findGroup('member', 2), null, 'member/2 remains unresolved');
+        assertEqual(program.autoloadedPredicates.length, 0, 'no autoloads');
+      },
+    },
     {
       name: 'program and solver public classes',
       run: () => {
@@ -3345,10 +3432,15 @@ open(X) :- candidate(X), \\+ closed(X).
         assertEqual(Boolean(library.get('statistics', 0)), true, 'statistics/0 is an EyeProlog observability extension');
         assertEqual(Boolean(library.get('statistics', 2)), true, 'statistics/2 is an EyeProlog observability extension');
         assertEqual(registeredNativeEyePrologLibraryNames().length, 40, 'public native EyeProlog builtin count');
-        assertEqual(eyePrologPortableLibraryIndicators.length, 59, 'portable Prolog library count');
+        assertEqual(eyePrologPortableLibraryIndicators.length, 62, 'portable Prolog library count');
+        assertEqual(eyePrologInteropLibraryIndicators.length, 26, 'cross-implementation interop profile count');
+        assertEqual(eyePrologInteropLibraryModules.join(','), 'lists', '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['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');
-        assertEqual(eyePrologLibraryIndicators.length, 99, 'complete EyeProlog library surface');
+        assertEqual(eyePrologLibraryIndicators.length, 102, 'complete EyeProlog library surface');
         assertEqual(registry.get('eyeprolog__call_nth', 2), null, 'private call_nth adapter is absent from ISO registry');
         assertEqual(Boolean(library.get('eyeprolog__call_nth', 2)), true, 'private call_nth adapter is registered for EyeProlog');
         assertEqual(library.get('eyeprolog__call_nth', 2)?.eyePrologLibrary, true, 'private adapter is marked as library support');

package/the-art-of-eyeprolog.md

@@ -1065,7 +1065,6 @@ safe_reading(Sensor, Value) :-
 already-bound value:
 
 ```eyeprolog
-:- use_module(library(prologue), [between/3]).
 :- use_module(library(lists)).
 
 square(N, Square) :-
@@ -5975,8 +5974,8 @@ so side effects occur in Prolog execution order.
 
 ### The EyeProlog library
 
-EyeProlog exposes **99 library predicate indicators** in addition to the 129
-indicators in its isolated ISO profile. **60 are defined as ordinary Prolog
+EyeProlog exposes **102 library predicate indicators** in addition to the 129
+indicators in its isolated ISO profile. **63 are defined as ordinary Prolog
 clauses** in focused modules under `src/lib/`. The remaining 39
 are public wrappers around backtrackable host support: Prologue `call_nth/2` and
 `freeze/2`, plus the 37-predicate finite-domain `library(clpz)` kernel. The
@@ -5994,9 +5993,10 @@ only the modules it needs, and
 module implements p.p.1 through p.p.11 of the
 [working-draft Prologue](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/prologue),
 with the published Prologue, `call_nth/2`, and `length/2` quads retained as
-offline regressions. `src/standard-library.js` registers the module sources and
-private control and constraint adapters for Node and browser resolution, and never adds clauses
-implicitly.
+offline regressions. `src/standard-library.js` registers the module sources and private control and
+constraint adapters for Node and browser resolution. Explicit `use_module/1-2`
+loads remain supported; outside strict ISO mode, the conservative interop
+autoloader may also load a module for one uniquely mapped common predicate.
 The core registry remains available through `createDefaultRegistry()` and
 `getDefaultRegistry()` for low-level embedding. The stricter Part 1 +
 Corrigenda registry is exposed as `createStrictIsoRegistry()` and
@@ -6018,7 +6018,7 @@ between solution branches.
 | `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)` | `maplist/3`, `append/3`, `member/2`, `select/3`, `last/2`, `nth0/3`, `nth1/3`, `reverse/2`, `length/2`, `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(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(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` |
@@ -6027,6 +6027,35 @@ between solution branches.
 
 <!-- eyeprolog-library-catalog:end -->
 
+#### Interoperability profile and conservative autoloading
+
+The full EyeProlog library is larger than the deliberately conservative
+EyeProlog/Trealla/Scryer source-interoperability profile. The two concepts are
+kept separate: a predicate can be implemented as ordinary portable Prolog and
+still have an API that is not shared by the other systems.
+
+`library(lists)` is the first aligned common module. Its interop surface includes
+`member/2`, `memberchk/2`, `select/3`, `append/2-3`, `last/2`,
+`same_length/2`, `nth0/3-4`, `nth1/3-4`, `reverse/2`, `length/2`,
+`maplist/2-8`, `foldl/4-6`, `sum_list/2`, and `list_to_set/2`. EyeProlog-only
+helpers such as `set_nth0/4`, `take/3`, `drop/3`, and `slice/4` remain available
+for compatibility but are outside this profile.
+
+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` is also in the interop profile;
+EyeProlog can satisfy it 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`.
+
+`-w` / `--warnings` reports explicit non-profile library dependencies and calls
+to non-profile predicates from common libraries. `--portable` turns those
+portability diagnostics into a failing command, making the profile suitable for
+continuous integration. `npm run test:interop` executes the same Sudoku source
+under EyeProlog, Trealla, and Scryer when those commands are installed; the
+repository's interoperability workflow installs them and runs that check.
+
 `library(clpz)` follows the Trealla and Scryer convention for constraint logic
 programming over integers. Its first implementation step provides finite
 interval and union domains, arithmetic and reified constraints, backtrackable
@@ -6420,7 +6449,9 @@ make the observed question explicit.
 | `-h`, `--help` | Show usage |
 | `-p`, `--proof` | Print `why/2` explanations |
 | `-q`, `--quads` | Run embedded quad tests and fail if any do not hold |
-| `--iso-strict` | Restrict parsing and execution to ISO/IEC 13211-1:1995 + Corrigenda 1–3; reject EyeProlog language extensions and disable automatic tabling |
+| `--iso-strict` | Restrict parsing and execution to ISO/IEC 13211-1:1995 + Corrigenda 1–3; reject EyeProlog language extensions, disable interop autoloading, and disable automatic tabling |
+| `--portable` | Enforce the conservative EyeProlog/Trealla/Scryer interoperability profile |
+| `--no-autoload` | Disable conservative interop predicate autoloading |
 | `-s`, `--stats` | Print final solver and memory statistics to stderr after execution |
 | `-v`, `--version` | Print the package version |
 | `-w`, `--warnings` | Print non-fatal portability warnings |
@@ -6434,8 +6465,9 @@ retains the Part 1 prefix `(?-)/1` operator and treats `-->/2` as ordinary Part
 1 operator syntax; it does not perform Part 3 grammar-rule expansion or expose
 `phrase/2-3`. Part 2 module directives and EyeProlog libraries are rejected,
 the implementation-specific `occurs_check` flag is absent, and automatic
-tabling/recursion guards are disabled. Normal mode is unchanged and continues
-to support Parts 2–3 and EyeProlog extensions.
+tabling/recursion guards are disabled. Normal mode continues to support Parts
+2–3 and EyeProlog extensions, plus conservative interop autoloading for the
+profile documented above.
 
 Inputs may be local files, HTTP(S) URLs, or one `-` for stdin. The bare command
 `eyeprolog` starts the normal REPL; `eyeprolog --iso-strict` starts the strict
@@ -6462,7 +6494,7 @@ Work in a fixed sequence:
 2. run without observation flags and compare stdout with that prediction;
 3. add `--proof` when the support for an answer is the question;
 4. add `--warnings` when portability or negative dependencies are the
-   question;
+   question; use `--portable` when non-profile dependencies must fail CI;
 5. add `--stats` only when comparing two executions of the same semantic case.
 
 For example:
@@ -6471,6 +6503,7 @@ For example:
 eyeprolog --goal 'ancestor(X, Y)' examples/ancestor.pl
 eyeprolog --proof --goal 'type(X, Y)' examples/socrates.pl
 eyeprolog --warnings --goal 'answer(X)' test/conformance/warnings/negation/unstratified_mutual.pl
+eyeprolog --portable --goal 'sudoku_solution(S)' examples/sudoku.pl
 eyeprolog --stats --goal 'path(a, X)' examples/path-discovery.pl > answers.pl 2> run.stats
 ```