eyeprolog 1.2.44 → 1.3.1

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,140 @@ 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: 'library(lists) length/2 stays relational and call_nth/2 autoloads (issue #28)',
+      run: () => {
+        const input = [
+          ':- use_module(library(lists)).',
+          '%% goal: fourth_length(N)',
+          'fourth_length(N) :- call_nth(length(_Xs, N), 4).',
+          '',
+        ].join('\n');
+        const result = runCli(['-'], { input });
+        assertEqual(result.status, 0, 'exit status');
+        assertEqual(result.stdout, 'fourth_length(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 +3092,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 +3447,16 @@ 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, 27, '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['call_nth/2'], 'prologue', 'call_nth/2 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,39 @@ 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`. Its `length/2`
+is fully relational: when both arguments are variables, `length(Xs, N)`
+enumerates `Xs = [], N = 0`, then one-element lists with `N = 1`, and so on.
+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.
+
+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`.
+
+`-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 +6453,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 +6469,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 +6498,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 +6507,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
 ```