eyeprolog 1.1.9 → 1.1.11

package/README.md

@@ -21,11 +21,22 @@ examples, proofs, conformance, and implementation.
 
 ## Quick start
 
-EyeProlog requires Node.js 18 or newer.
+EyeProlog requires Node.js 18 or newer. Check the active runtime before
+installing:
 
 ```sh
-npm install --global eyeprolog
-eyeprolog
+node --version
+```
+
+If it reports an older release, upgrade through a Node version manager or the
+[official Node.js download](https://nodejs.org/en/download) and check again.
+Distribution packages can provide an older Node.js even on a current operating
+system.
+
+Run EyeProlog without a global installation:
+
+```sh
+npx --yes eyeprolog
 ?- use_module(library(lists)).
    true.
 ?- member(X, [prolog, logic]).
@@ -34,11 +45,25 @@ eyeprolog
 ?- halt.
 ```
 
+For a persistent `eyeprolog` command without administrator access, install it
+under a user-owned prefix and put that prefix's `bin` directory on `PATH`:
+
+```sh
+npm install --global --prefix "$HOME/.local" eyeprolog
+export PATH="$HOME/.local/bin:$PATH"
+eyeprolog
+```
+
+Add the `PATH` export to your shell startup file to keep it across sessions.
+Do not use `sudo npm install`; npm's
+[EACCES guidance](https://docs.npmjs.com/resolving-eacces-permissions-errors-when-installing-packages-globally/)
+also recommends a Node version manager or a user-owned npm prefix.
+
 For a non-interactive run:
 
 ```sh
 printf 'human(socrates).\nmortal(X) :- human(X).\n' |
-  eyeprolog --proof --goal 'mortal(socrates)' -
+  npx --yes eyeprolog --proof --goal 'mortal(socrates)' -
 ```
 
 Programs may declare their default queries with `%% goal:` comments.
@@ -66,12 +91,12 @@ noun --> [world] | [prolog].
 %% goal: phrase(sentence, Words)
 ```
 
-EyeProlog also adds 44 public library predicates to its 129-entry ISO registry.
-**All 44 are ordinary Prolog clauses** in `src/lib/eyeprolog.pl` and
-`src/lib/lists.pl`. They are ISO/IEC 13211-2 modules, loaded explicitly with
-`use_module(library(eyeprolog))` or `use_module(library(lists))`, following the
-layout used by Scryer Prolog. None requires host support. Portable text
-predicates use ISO atoms or character lists.
+EyeProlog also adds 46 public library predicates to its 129-entry ISO registry.
+**All 46 are ordinary Prolog clauses** in `src/lib/eyeprolog.pl`,
+`src/lib/lists.pl`, and `src/lib/prologue.pl`. They are ISO/IEC 13211-2 modules,
+loaded explicitly with `use_module(library(eyeprolog))`,
+`use_module(library(lists))`, or `use_module(library(prologue))`. None requires
+host support. Portable text predicates use ISO atoms or character lists.
 
 ## Development
 

package/package.json

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

package/src/lib/prologue.pl

@@ -0,0 +1,87 @@
+/** Predicates proposed by the ISO Prolog Prologue working draft. */
+
+:- module(prologue, [
+    member/2,
+    append/3,
+    length/2,
+    between/3,
+    select/3,
+    succ/2,
+    maplist/2
+]).
+
+:- meta_predicate(maplist(1, '?')).
+
+member(X, [X|_]).
+member(X, [_|Xs]) :- member(X, Xs).
+
+append([], Ys, Ys).
+append([X|Xs], Ys, [X|Zs]) :- append(Xs, Ys, Zs).
+
+length(List, Length) :-
+    nonvar(Length), !,
+    prologue__integer(Length),
+    prologue__not_less_than_zero(Length),
+    prologue__length_fixed(Length, List).
+length(List, Length) :-
+    prologue__length_generate(List, 0, Length).
+
+prologue__length_fixed(0, []).
+prologue__length_fixed(N, [_|Xs]) :-
+    N > 0,
+    Next is N - 1,
+    prologue__length_fixed(Next, Xs).
+
+prologue__length_generate([], N, N).
+prologue__length_generate([_|Xs], N0, N) :-
+    N1 is N0 + 1,
+    prologue__length_generate(Xs, N1, N).
+
+between(Lower, Upper, X) :-
+    prologue__integer(Lower),
+    prologue__integer(Upper),
+    prologue__integer_or_variable(X),
+    prologue__between(Lower, Upper, X).
+
+prologue__between(Lower, Upper, Lower) :- Lower =< Upper.
+prologue__between(Lower, Upper, X) :-
+    Lower < Upper,
+    Next is Lower + 1,
+    prologue__between(Next, Upper, X).
+
+select(X, [X|Xs], Xs).
+select(X, [Y|Ys], [Y|Zs]) :- select(X, Ys, Zs).
+
+succ(X, S) :-
+    var(X), !,
+    ( var(S) -> 0 is S
+    ; prologue__integer(S),
+      prologue__not_less_than_zero(S),
+      S > 0,
+      X is S - 1
+    ).
+succ(X, S) :-
+    prologue__integer(X),
+    prologue__not_less_than_zero(X),
+    ( var(S) -> S is X + 1
+    ; prologue__integer(S),
+      prologue__not_less_than_zero(S),
+      S =:= X + 1
+    ).
+
+maplist(_, []).
+maplist(Closure, [X|Xs]) :-
+    call(Closure, X),
+    maplist(Closure, Xs).
+
+prologue__integer_or_variable(X) :- var(X), !.
+prologue__integer_or_variable(X) :- prologue__integer(X).
+
+prologue__integer(X) :- integer(X), !.
+prologue__integer(X) :- var(X), !, 0 is X.
+% arg/3 performs the required integer type check before inspecting its term.
+prologue__integer(X) :- arg(X, type_check, _).
+
+prologue__not_less_than_zero(X) :- X >= 0, !.
+% atom_length/2 reports domain_error(not_less_than_zero) for a negative value.
+prologue__not_less_than_zero(X) :- atom_length('', X).

package/src/solver.js

@@ -431,6 +431,8 @@ function defaultPrologFlags(unknown = 'error') {
     ['integer_rounding_function', { value: compound('toward_zero', []), allowed: ['toward_zero'], changeable: false }],
     ['char_conversion', { value: compound('on', []), allowed: ['on', 'off'], changeable: true }],
     ['debug', { value: compound('off', []), allowed: ['on', 'off'], changeable: true }],
+    ['max_integer', { value: compound('unbounded', []), allowed: ['unbounded'], changeable: false }],
+    ['min_integer', { value: compound('unbounded', []), allowed: ['unbounded'], changeable: false }],
     ['max_arity', { value: compound('unbounded', []), allowed: ['unbounded'], changeable: false }],
     ['unknown', { value: compound(unknown, []), allowed: ['error', 'fail', 'warning'], changeable: true }],
     ['double_quotes', { value: compound('chars', []), allowed: ['chars', 'codes', 'atom'], changeable: true }],

package/src/standard-library.js

@@ -8,6 +8,7 @@ import { fs, isNode } from './platform.js';
 const moduleFiles = Object.freeze({
   eyeprolog: 'eyeprolog.pl',
   lists: 'lists.pl',
+  prologue: 'prologue.pl',
 });
 
 const cacheKey = isNode
@@ -36,14 +37,14 @@ function libraryUrl(filename) {
 
 export const eyePrologNativeLibraryIndicators = Object.freeze([]);
 export const eyePrologPortableLibraryIndicators = Object.freeze([
-  'uuid/3', 'difference/3', 'maplist/3', 'lt/2', 'gt/2', 'le/2', 'ge/2',
+  'uuid/3', 'difference/3', 'maplist/2', 'maplist/3', 'lt/2', 'gt/2', 'le/2', 'ge/2',
   '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',
   'nth0/3', 'nth1/3', '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',
-  'countall/2', 'sumall/3', 'aggregate_min/5', 'aggregate_max/5',
+  'countall/2', 'succ/2', 'sumall/3', 'aggregate_min/5', 'aggregate_max/5',
 ]);
 export const eyePrologLibraryIndicators = Object.freeze([...eyePrologPortableLibraryIndicators]);
 

package/test/conformance/expected/iso/exceptions_and_flags.pl

@@ -1,3 +1,3 @@
 answer(7, red, caught(eyeprolog), first, caught(eyeprolog)).
 answer(7, red, caught(eyeprolog), second, caught(eyeprolog)).
-flags(off, on, [pair(bounded, false), pair(integer_rounding_function, toward_zero), pair(char_conversion, on), pair(debug, off), pair(max_arity, unbounded), pair(unknown, fail), pair(double_quotes, chars)]).
+flags(off, on, [pair(bounded, false), pair(integer_rounding_function, toward_zero), pair(char_conversion, on), pair(debug, off), pair(max_integer, unbounded), pair(min_integer, unbounded), pair(max_arity, unbounded), pair(unknown, fail), pair(double_quotes, chars)]).

package/test/fixtures/README.md

@@ -8,3 +8,16 @@
 Retrieved on 2026-08-11. It is vendored so the regression suite exercises all
 58 quads without depending on network access or availability of the source
 server.
+
+`prologue_quad.pl` is an unmodified snapshot of the 33 machine-readable quads
+for the predicates proposed by the Prolog Prologue working draft:
+
+<https://www.complang.tuwien.ac.at/ulrich/iso-prolog/prologue_quad.pl>
+
+The corresponding working draft is at
+<https://www.complang.tuwien.ac.at/ulrich/iso-prolog/prologue>.
+The corpus snapshot was retrieved on 2026-08-11.
+
+`prologue_quad_runner.pl` loads EyeProlog's `library(prologue)` and includes
+the unmodified corpus, mirroring the draft's requirement that a Prologue be
+included before its examples are run.

package/test/fixtures/prologue_quad.pl

@@ -0,0 +1,134 @@
+% p.p.1 member/2
+
+?- member(X, [1,2]).
+   X = 1
+;  X = 2.
+
+?- member(1, L).
+   L = [1|_]
+;  L = [_,1|_]
+;  L = [_,_,1|_]
+;  ... . % Ad infinitum.
+
+?- member(X, [Y,Z|nonlist]).
+   X = Y
+;  X = Z.
+
+?- member(X, nonlist).
+   false.
+
+?- member(X, X).
+   sto,  % undefined, STO 7.3.3
+   true
+|  sto,
+   loops.
+
+% p.p.2 append/3
+
+?- append([a,b],[c,d], Xs).
+   Xs = [a,b,c,d].
+
+?- append([a], nonlist, Xs).
+   Xs = [a|nonlist].
+
+?- append([a], Ys, Zs).
+   Zs = [a|Ys].
+
+?- append(Xs, Ys, [a,b,c]).
+   Xs = [], Ys = [a,b,c]
+;  Xs = [a], Ys = [b,c]
+;  Xs = [a,b], Ys = [c]
+;  Xs = [a,b,c], Ys = [].
+
+% p.p.3 length/2
+
+?- length([a,b,c], Length).
+   Length = 3.
+
+?- length(List, 5).
+   List = [_,_,_,_,_].
+
+?- length(List, Length).
+   List = [], Length = 0
+;  List = [_], Length = 1
+;  List = [_,_], Length = 2
+;  ... . % Ad infinitum.
+
+% p.p.4 between/3
+
+?- between(1, 2, 0).
+   false.
+
+?- between(1, 2, I).
+   I = 1
+;  I = 2.
+
+?- between(2, 1, I).
+   false.
+
+?- between(I, I, 0).
+   instantiation_error.
+
+?- between(1, I, 0).
+   instantiation_error.
+
+?- between(I, -1, 0).
+   instantiation_error.
+
+?- between(1, c, 0).
+   type_error(integer,c).
+
+?- between(1+1,2,I).
+   type_error(integer,1+1).
+
+% p.p.5 select/3
+
+?- select(X, [1,2], Xs).
+   X = 1, Xs = [2]
+;  X = 2, Xs = [1].
+
+?- select(X, [Y|nonlist], Xs).
+   X = Y, Xs = nonlist.
+
+?- select(E, Xs, Xs).
+   sto.
+
+% p.p.6 succ/2
+
+?- succ(X, S).
+   instantiation_error.
+
+?- succ(X, X).
+   instantiation_error.
+
+?- succ(0, S).
+   S = 1.
+
+?- succ(1, 1+1).
+   type_error(integer, 1+1).
+
+?- succ(X, 0).
+   false.
+
+?- succ(-1, S).
+   domain_error(not_less_than_zero, -1).
+
+?- current_prolog_flag(max_integer, Max),
+   ( integer(Max) -> succ(Max, S) ; true ).
+   evaluation_error(int_overflow)
+|  Max = unbounded.
+
+% p.p.7
+
+?- maplist(>(3), [1, 2]).
+   true.
+
+?- maplist(>(3), [1, 2, 3]).
+   false.
+
+?- maplist(=(X), Xs).
+   Xs = []
+;  Xs = [X]
+;  Xs = [X, X]
+;  Xs = [X, X, X]
+;  ... . % Ad infinitum.

package/test/fixtures/prologue_quad_runner.pl

@@ -0,0 +1,2 @@
+:- use_module(library(prologue)).
+:- include('prologue_quad.pl').

package/test/run-regression.mjs

@@ -322,6 +322,21 @@ c4 ?- call((!;1)).
         assertEqual(result.stdout, 'quads: 58 run, 58 passed, 0 failed.\n', 'quad report');
       },
     },
+    {
+      name: 'runQuads passes the complete vendored Prolog Prologue quad corpus',
+      run: () => {
+        const filename = path.join(testRoot, 'fixtures', 'prologue_quad_runner.pl');
+        const source = fs.readFileSync(filename, 'utf8');
+        const result = publicApi.runQuads(Program.parseSources([{
+          text: source,
+          filename,
+          baseDir: path.dirname(filename),
+        }]));
+        assertEqual(result.total, 33, 'quad total');
+        assertEqual(result.passed, 33, 'quad passed');
+        assertEqual(result.stdout, 'quads: 33 run, 33 passed, 0 failed.\n', 'quad report');
+      },
+    },
     {
       name: 'runQuads rejects malformed answer substitutions',
       run: () => {
@@ -501,6 +516,27 @@ c4 ?- call((!;1)).
         assertEqual(result.stderr, '', 'stderr');
       },
     },
+    {
+      name: 'npm can install the CLI under a user-owned prefix',
+      run: () => {
+        const prefix = path.join(tmp, `npm-prefix-${++tmpCounter}`);
+        const installed = spawnSync('npm', [
+          'install', '--global', '--prefix', prefix, '--loglevel=silent', '--no-audit', '--no-fund', '.',
+        ], {
+          cwd: packageRoot,
+          encoding: 'utf8',
+          env: { ...process.env, npm_config_update_notifier: 'false' },
+        });
+        assertEqual(installed.status, 0, 'install exit status');
+        const executable = process.platform === 'win32'
+          ? path.join(prefix, 'eyeprolog.cmd')
+          : path.join(prefix, 'bin', 'eyeprolog');
+        const result = spawnSync(executable, ['--version'], { encoding: 'utf8' });
+        assertEqual(result.status, 0, 'installed CLI exit status');
+        assertEqual(result.stdout, `eyeprolog ${pkg.version}\n`, 'installed CLI stdout');
+        assertEqual(result.stderr, '', 'installed CLI stderr');
+      },
+    },
     {
       name: 'stdin input is accepted',
       run: () => {
@@ -861,7 +897,7 @@ function documentationSyncCases() {
           '<a href="https://eyereasoner.github.io/eyeprolog/the-art-of-eyeprolog">\n    <img src="book-assets/title-page.svg" alt="Read The Art of EyeProlog"',
           'README cover links to the book',
         );
-        for (const filename of ['src/iso.js', 'src/dcg.js', 'src/standard-library.js', 'src/lib/eyeprolog.pl', 'src/lib/lists.pl', 'src/playground-worker.js']) {
+        for (const filename of ['src/iso.js', 'src/dcg.js', 'src/standard-library.js', 'src/lib/eyeprolog.pl', 'src/lib/lists.pl', 'src/lib/prologue.pl', 'src/playground-worker.js']) {
           assertEqual(fs.existsSync(path.join(packageRoot, filename)), true, `${filename} exists`);
           assertIncludes(book, filename, `book documents ${filename}`);
         }
@@ -964,6 +1000,22 @@ function documentationSyncCases() {
         assertArrayEqual(misleadingDependencyInstallDocs(), [], 'misleading dependency install docs');
       },
     },
+    {
+      name: 'installation docs avoid unsupported Node and global npm permission traps',
+      run: () => {
+        assertEqual(pkg.engines?.node, '>=18', 'supported Node range');
+        for (const filename of ['README.md', 'the-art-of-eyeprolog.md']) {
+          const text = fs.readFileSync(path.join(packageRoot, filename), 'utf8');
+          assertIncludes(text, 'node --version', `${filename} checks Node version`);
+          assertIncludes(text, 'npx --yes eyeprolog', `${filename} offers a non-global launch`);
+          assertIncludes(text, 'npm install --global --prefix "$HOME/.local" eyeprolog', `${filename} uses a user prefix`);
+          assertIncludes(text, 'https://nodejs.org/en/download', `${filename} links Node upgrades`);
+          assertIncludes(text, 'https://docs.npmjs.com/resolving-eacces-permissions-errors-when-installing-packages-globally/', `${filename} links npm EACCES guidance`);
+          assertEqual(text.includes('sudo npm install'), true, `${filename} explicitly warns against sudo npm`);
+          assertEqual(/^\s*sudo npm install/m.test(text), false, `${filename} never recommends sudo npm`);
+        }
+      },
+    },
   ];
 }
 
@@ -1300,10 +1352,10 @@ open(X) :- candidate(X), \\+ closed(X).
         assertEqual(Boolean(registry.get('phrase', 2)), true, 'Part 3 phrase/2 exists');
         assertEqual(Boolean(registry.get('phrase', 3)), true, 'Part 3 phrase/3 exists');
         assertEqual(registeredNativeEyePrologLibraryNames().length, 0, 'public native EyeProlog builtin count');
-        assertEqual(eyePrologPortableLibraryIndicators.length, 44, 'portable Prolog library count');
+        assertEqual(eyePrologPortableLibraryIndicators.length, 46, 'portable Prolog library count');
         assertEqual(eyePrologNativeLibraryIndicators.length, 0, 'native host library count');
         assertEqual(eyePrologNativeLibraryIndicators.join(','), '', 'no EyeProlog library predicate requires host support');
-        assertEqual(eyePrologLibraryIndicators.length, 44, 'complete EyeProlog library surface');
+        assertEqual(eyePrologLibraryIndicators.length, 46, 'complete EyeProlog library surface');
         assertEqual(library.get('between', 3), null, 'between/3 remains portable Prolog');
         assertEqual(library.get('smallest_divisor_from', 3), null, 'smallest_divisor_from/3 remains portable Prolog');
         assertEqual(library.get('random', 3), null, 'random/3 remains portable Prolog');
@@ -1331,6 +1383,7 @@ open(X) :- candidate(X), \\+ closed(X).
         assertEqual(fs.existsSync(path.join(packageRoot, 'src', 'lib', 'eyeprolog.pl')), true, 'portable module exists');
         assertEqual(fs.existsSync(path.join(packageRoot, 'src', 'standard-library.js')), true, 'standard module registry exists');
         assertEqual(fs.existsSync(path.join(packageRoot, 'src', 'lib', 'lists.pl')), true, 'lists module exists');
+        assertEqual(fs.existsSync(path.join(packageRoot, 'src', 'lib', 'prologue.pl')), true, 'Prologue module exists');
         assertEqual(fs.existsSync(path.join(packageRoot, 'src', 'eyeprolog-autoload.js')), false, 'obsolete autoloader is absent');
         assertEqual(fs.existsSync(path.join(packageRoot, 'src', 'library-source.js')), false, 'duplicate source loader is absent');
         assertEqual(fs.existsSync(path.join(packageRoot, 'src', 'portable-library.js')), false, 'obsolete duplicate module remains absent');

package/the-art-of-eyeprolog.md

@@ -79,6 +79,30 @@ Then ask for the derivations:
 node bin/eyeprolog.js --proof examples/socrates.pl
 ```
 
+To use the published package, first verify that `node --version` reports Node.js
+18 or newer. Upgrade an older runtime through a Node version manager or the
+[official Node.js download](https://nodejs.org/en/download). A current Linux
+distribution can still expose an older Node.js package.
+
+The package can be launched without a global installation:
+
+```sh
+npx --yes eyeprolog
+```
+
+For a persistent command without administrator access, install into a
+user-owned prefix:
+
+```sh
+npm install --global --prefix "$HOME/.local" eyeprolog
+export PATH="$HOME/.local/bin:$PATH"
+```
+
+Persist the `PATH` export in the appropriate shell startup file. Do not use
+`sudo npm install`; npm's
+[EACCES guidance](https://docs.npmjs.com/resolving-eacces-permissions-errors-when-installing-packages-globally/)
+recommends a Node version manager or a user-owned npm prefix.
+
 Readers who do not want to install anything can begin in the
 [browser playground](https://eyereasoner.github.io/eyeprolog/playground). Paste
 the source of `examples/socrates.pl` into the editor and run it. The playground
@@ -5580,6 +5604,8 @@ silently changing a static program.
 | `integer_rounding_function` | `toward_zero` | `toward_zero` | no |
 | `char_conversion` | `on` | `on`, `off` | yes |
 | `debug` | `off` | `on`, `off` | yes |
+| `max_integer` | `unbounded` | `unbounded` | no |
+| `min_integer` | `unbounded` | `unbounded` | no |
 | `max_arity` | `unbounded` | `unbounded` | no |
 | `unknown` | `fail` | `error`, `fail`, `warning` | yes |
 | `double_quotes` | `chars` | `chars`, `codes`, `atom` | yes |
@@ -5735,17 +5761,20 @@ so side effects occur in Prolog execution order.
 
 ### The EyeProlog library
 
-EyeProlog exposes **44 library predicate indicators** in addition to the 129
-indicators in its isolated ISO profile. **All 44 are ordinary Prolog clauses**
-across `src/lib/eyeprolog.pl` and `src/lib/lists.pl`; none
+EyeProlog exposes **46 library predicate indicators** in addition to the 129
+indicators in its isolated ISO profile. **All 46 are ordinary Prolog clauses**
+across `src/lib/eyeprolog.pl`, `src/lib/lists.pl`, and `src/lib/prologue.pl`; none
 is a native host predicate. The resulting
-normal EyeProlog language surface is therefore **173 public predicate
+normal EyeProlog language surface is therefore **175 public predicate
 indicators**. Internally, the runtime registry contains only the 129 ISO
 definitions; the EyeProlog relations are module source clauses.
 
-The two Prolog files declare `eyeprolog` and `lists` with `module/2`. A program
-loads them explicitly with `use_module(library(eyeprolog))` and
-`use_module(library(lists))`; `use_module/2` can select a smaller import list.
+The three Prolog files declare `eyeprolog`, `lists`, and `prologue` with
+`module/2`. A program loads them explicitly with
+`use_module(library(eyeprolog))`, `use_module(library(lists))`, or
+`use_module(library(prologue))`; `use_module/2` can select a smaller import
+list. The last module implements the predicates exercised by the working-draft
+Prologue quad corpus.
 `src/standard-library.js` only registers the module sources for Node and browser
 resolution and never adds clauses implicitly.
 The isolated ISO-only registry remains
@@ -5759,6 +5788,7 @@ private helpers and same-named predicates in different modules separate.
 | --- | --- |
 | `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` |
 | `library(eyeprolog)` | `uuid/3`, `difference/3`, `lt/2`, `le/2`, `gt/2`, `ge/2`, `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`, `string_concat/3`, `contains/2`, `matches/2`, `join/3`, `substring/4`, `set_nth0/4`, `take/3`, `drop/3`, `slice/4`, `sumall/3`, `aggregate_min/5`, `aggregate_max/5` |
+| `library(prologue)` | `member/2`, `append/3`, `length/2`, `between/3`, `select/3`, `succ/2`, `maplist/2` |
 
 <!-- eyeprolog-library-catalog:end -->
 
@@ -5885,7 +5915,7 @@ eyeprolog --goal 'answer(Kind, Value)' program.pl
 The portable text API uses **ISO atoms or proper lists of one-character atoms**.
 A generated text result defaults to an atom. Double-quoted source text uses the
 ISO representation selected by `double_quotes`; with the default `chars`, it is
-already a proper character list accepted by this API. The 44-predicate portable
+already a proper character list accepted by this API. The 46-predicate portable
 library itself has no STRING or JavaScript dependency.
 
 | Predicate and principal mode | Behavior |