eyeprolog 0.5.12 → 0.5.13

package/README.md

@@ -32,9 +32,11 @@ Programs may declare their default queries with `%% goal:` comments.
 ## Portable library
 
 EyeProlog adds 50 public library predicates to its 115-predicate ISO profile.
-**All 50 are ordinary Prolog clauses** in `src/eyeprolog-library.pl` and are
-autoloaded in Node and the browser. None requires host support. Portable text
-predicates use ISO atoms or character lists; the
+**All 50 are ordinary Prolog clauses** across `src/eyeprolog-library.pl` and
+`src/eyeprolog-common-library.pl`; both are autoloaded in Node and the
+browser. None requires host support. Other Prolog systems should load only
+`eyeprolog-library.pl`, which avoids redefining their common list predicates.
+Portable text predicates use ISO atoms or character lists; the
 RDF tools emit lexical values as ISO atoms as well.
 
 ## RDF 1.2

package/examples/age.pl

@@ -27,4 +27,4 @@ ageAbove(S, A) :-
 
 % Test mirroring the Eyeling example.
 holds_result(test, true) :-
-  ageAbove(S, 'P80Y').
+  ageAbove(_, 'P80Y').

package/examples/blocks-world-planning.pl

@@ -48,7 +48,7 @@ move(State, move(Block, From, To), Newstate) :-
   (Block \= To),
   (From \= To),
   select(on(Block, From), State, Rest),
-  sort([on(Block, To)|Rest], Newstate).
+  sort_unique([on(Block, To)|Rest], Newstate).
 
 plan(State, Goal, 0, _visited, [], State) :-
   (State = Goal).
@@ -63,8 +63,8 @@ plan(State, Goal, Depth, Visited, [Move|Moves], Final) :-
 five_move_plan(Moves, Final) :-
   initial(Start),
   goal(Goal),
-  sort(Start, Sortedstart),
-  sort(Goal, Sortedgoal),
+  sort_unique(Start, Sortedstart),
+  sort_unique(Goal, Sortedgoal),
   plan(Sortedstart, Sortedgoal, 5, [Sortedstart], Moves, Final).
 
 status(blocks_world, planned) :-

package/examples/combinatorics-findall-sort.pl

@@ -1,7 +1,7 @@
-% Eyelet-inspired combinations example using findall/3 and sort/2.
+% Eyelet-inspired combinations example using findall/3 and sort_unique/2.
 %
 % combination/3 generates the same subset in several selection orders.  findall/3
-% collects those candidates, and sort/2 canonicalizes the list so each unordered
+% collects those candidates, and sort_unique/2 canonicalizes the list so each unordered
 % 3-combination of five items is reported once.
 %% goal: combinations(X0, X1)
 
@@ -24,12 +24,12 @@ combination(I, Items, Combination) :-
   select(Item, Items, Remaining),
   (J is I - 1),
   combination(J, Remaining, Partial),
-  sort([Item | Partial], Combination).
+  sort_unique([Item | Partial], Combination).
 
 % findall collects all generation orders; sort canonicalizes and deduplicates.
 unique_combinations(K, Items, Unique) :-
   findall(C, combination(K, Items, C), All),
-  sort(All, Unique).
+  sort_unique(All, Unique).
 
 combinations(combinations_5_choose_3, Unique) :-
   unique_combinations(3, [1, 2, 3, 4, 5], Unique).

package/examples/d3-group.pl

@@ -1,4 +1,4 @@
-% Eyelet-inspired D3 group example using findall/3 and sort/2.
+% Eyelet-inspired D3 group example using findall/3 and sort_unique/2.
 % The six facts are the symmetries of an equilateral triangle, with compose/3 as
 % the Cayley table and inverse/2 as the inverse relation.  Candidate subsets are
 % generated as subsequences, then filtered for subgroup closure.
@@ -72,7 +72,7 @@ subsequence([_head | Tail], Rest) :-
 
 all_symmetries(Symmetries) :-
   findall(X, symmetry(X), Raw),
-  sort(Raw, Symmetries).
+  sort_unique(Raw, Symmetries).
 
 % A valid subgroup is closed under both composition and inverse.
 closed_under_composition(Group) :-
@@ -90,7 +90,7 @@ valid_group(Group) :-
 
 all_subgroups(Groups) :-
   findall(G, valid_group(G), Raw),
-  sort(Raw, Groups).
+  sort_unique(Raw, Groups).
 
 subgroups(d3_group, Groups) :-
   all_subgroups(Groups).

package/examples/dijkstra-findall-sort.pl

@@ -1,7 +1,7 @@
-% Eyelet-inspired Dijkstra example using findall/3 and sort/2.
+% Eyelet-inspired Dijkstra example using findall/3 and sort_unique/2.
 % The priority queue is represented as sorted list entries [Cost, Node | Path].
 % Each expansion collects unvisited neighbors with findall/3, appends them to
-% the frontier, and uses sort/2 so the cheapest frontier entry is processed next.
+% the frontier, and uses sort_unique/2 so the cheapest frontier entry is processed next.
 
 %% goal: shortestPath(X0, X1)
 
@@ -34,7 +34,7 @@ dijkstra_queue([[Cost, Node | Path] | Queue], Goal, Visited, Resultpath, Resultc
     (edge(Node, Neighbor, Weight), \+ member(Neighbor, Visited), (Newcost is Cost + Weight)),
     Neighbors),
   append(Queue, Neighbors, Newqueue),
-  sort(Newqueue, Sortedqueue),
+  sort_unique(Newqueue, Sortedqueue),
   dijkstra_queue(Sortedqueue, Goal, [Node | Visited], Resultpath, Resultcost).
 
 shortestPath(dijkstra_findall_sort, Path) :-

package/examples/enigma1225.pl

@@ -89,7 +89,7 @@ eval_matrix(Matrix, FreqSorted) :-
     setof(E, member(E, Entries), Set),
     maplist(count_var(Entries), Set, Multiplicities),
     zip(Multiplicities, Set, Frequencies),
-    sort(Frequencies, FreqSorted),
+    sort_unique(Frequencies, FreqSorted),
     maplist(snd, FreqSorted, VarsSorted),
     length(VarsSorted, NVars),
     from_to(1, NVars, VarsSorted).
@@ -237,4 +237,3 @@ lists_reform([[A|B]|C], [A|D], [B|E]) :-
 
 % query
 %% goal: enigma1225(8, _)
-

package/examples/eulerian-path.pl

@@ -1,4 +1,4 @@
-% Eyelet-inspired Eulerian path example using findall/3 and sort/2.
+% Eyelet-inspired Eulerian path example using findall/3 and sort_unique/2.
 %
 % The graph is undirected; edges have identifiers so the trail consumes each
 % physical edge exactly once even when vertices are revisited.  The remaining
@@ -49,15 +49,15 @@ odd_degree(V) :-
 
 odd_vertices(Odds) :-
   findall(V, odd_degree(V), Raw),
-  sort(Raw, Odds).
+  sort_unique(Raw, Odds).
 
 all_edges(Edges) :-
   findall(E, edge(E, _a, _b), Raw),
-  sort(Raw, Edges).
+  sort_unique(Raw, Edges).
 
 vertices(Vertices) :-
   findall(V, vertex(V), Raw),
-  sort(Raw, Vertices).
+  sort_unique(Raw, Vertices).
 
 eulerian_start(Start) :-
   odd_vertices([Start, _end]).

package/examples/four-color-map.pl

@@ -102,13 +102,13 @@ border_count(36).
 
 all_countries_coloured(map_eu) :-
   findall(Country, valid_assignment(Country), Countries),
-  sort(Countries, Uniquecountries),
+  sort_unique(Countries, Uniquecountries),
   length(Uniquecountries, Count),
   country_count(Count).
 
 all_borders_checked(map_eu) :-
   findall([A, B], border_colours_differ(A, B), Borders),
-  sort(Borders, Uniqueborders),
+  sort_unique(Borders, Uniqueborders),
   length(Uniqueborders, Count),
   border_count(Count).
 

package/examples/input/odrl-dpv-healthcare-risk-ranked-rules.pl

@@ -15,7 +15,7 @@ healthcare_risk_report(Ranked) :-
     ),
     Unsorted
   ),
-  sort(Unsorted, Sorted),
+  sort_unique(Unsorted, Sorted),
   ranked_values(Sorted, 1, Ranked).
 
 risk_report(Risk, Score, Level, Clause, Mitigation) :-

package/examples/input/odrl-dpv-risk-ranked-rules.pl

@@ -15,7 +15,7 @@ consumer_risk_report(Ranked) :-
     ),
     Unsorted
   ),
-  sort(Unsorted, Sorted),
+  sort_unique(Unsorted, Sorted),
   ranked_values(Sorted, 1, Ranked).
 
 risk_report(Risk, Score, Level, Clause, Mitigation) :-

package/examples/input/rdf12-annotated-claims-rules.pl

@@ -25,7 +25,7 @@ ranked_claims(Claims) :-
     ),
     Unsorted
   ),
-  sort(Unsorted, Sorted),
+  sort_unique(Unsorted, Sorted),
   pair_values(Sorted, Claims).
 
 annotated_status_claim(Status, Source, Score) :-

package/examples/odrl-dpv-healthcare-risk-ranked.pl

@@ -56,7 +56,7 @@ healthcare_risk_report(Ranked) :-
     ),
     Unsorted
   ),
-  sort(Unsorted, Sorted),
+  sort_unique(Unsorted, Sorted),
   ranked_values(Sorted, 1, Ranked).
 
 risk_report(Risk, Score, Level, Clause, Mitigation) :-

package/examples/odrl-dpv-risk-ranked.pl

@@ -68,7 +68,7 @@ consumer_risk_report(Ranked) :-
     ),
     Unsorted
   ),
-  sort(Unsorted, Sorted),
+  sort_unique(Unsorted, Sorted),
   ranked_values(Sorted, 1, Ranked).
 
 risk_report(Risk, Score, Level, Clause, Mitigation) :-

package/examples/proof/age.pl

@@ -36,7 +36,7 @@ why(
   proof(
     goal(holds_result(test, true)),
     by(rule("age.pl", clause(5))),
-    bindings([binding("S", patH)]),
+    bindings([binding("__anon0", patH)]),
     uses([
       proof(
         goal(ageAbove(patH, 'P80Y')),

package/examples/proof/d3-group.pl

@@ -16,8 +16,8 @@ why(
             by(builtin(findall, 3))
           ),
           proof(
-            goal(sort([], [])),
-            by(library(sort, 2))
+            goal(sort_unique([], [])),
+            by(library(sort_unique, 2))
           )
         ])
       )
@@ -43,8 +43,8 @@ why(
             by(builtin(findall, 3))
           ),
           proof(
-            goal(sort([], [])),
-            by(library(sort, 2))
+            goal(sort_unique([], [])),
+            by(library(sort_unique, 2))
           )
         ])
       ),

package/examples/proof/iso-dynamic-database.pl

@@ -12,7 +12,7 @@ why(
         uses([
           proof(
             goal(task(check_power, urgent)),
-            by(fact("<input>", clause(299)))
+            by(fact("<input>", clause(303)))
           )
         ])
       )

package/examples/quine-mccluskey.pl

@@ -75,7 +75,7 @@ check(4, 'Canonical Tie-Breaking (Lexicographical First)', Status) :-
         find_combination(Size, Primes, C),
         covers_all(C, Minterms)
     ), Alternatives),
-    sort(Alternatives, [Best|_]),
+    sort_unique(Alternatives, [Best|_]),
     equality_status(Cover, Best, Status).
 
 check(5, 'Consistency (Solution is subset of Primes)', Status) :-
@@ -166,9 +166,9 @@ compute_primes(Primes) :-
     findall(B, (minterm(M), int_to_bits(M, B)), Mts),
     findall(B, (dont_care(D), int_to_bits(D, B)), Dcs),
     append(Mts, Dcs, All),
-    sort(All, Init),
+    sort_unique(All, Init),
     generate_loop(Init, [], RawPrimes),
-    sort(RawPrimes, Primes).
+    sort_unique(RawPrimes, Primes).
 
 generate_loop(Group, Acc, Final) :-
     findall(Nx-[P1,P2], (
@@ -176,8 +176,8 @@ generate_loop(Group, Acc, Final) :-
     ), Pairs),
     findall(N, member(N-_, Pairs), NextRaw),
     findall(P, (member(_-Pars, Pairs), member(P, Pars)), UsedRaw),
-    sort(NextRaw, NextGen),
-    sort(UsedRaw, Used),
+    sort_unique(NextRaw, NextGen),
+    sort_unique(UsedRaw, Used),
     findall(P, (member(P, Group), \+ member(P, Used)), New),
     append(Acc, New, AccUpd),
     (NextGen = [] -> Final = AccUpd ; generate_loop(NextGen, AccUpd, Final)).
@@ -187,13 +187,13 @@ solve_minimal_cover(Primes, MinimalCover) :-
     % 1. Essentials
     findall(M-Ps, (member(M, Minterms), findall(P, (member(P, Primes), covers_int(P, M)), Ps)), Chart),
     findall(P, member(_-[P], Chart), EssRaw),
-    sort(EssRaw, Essentials),
+    sort_unique(EssRaw, Essentials),
     % 2. Remaining
     remaining_minterms(Minterms, Essentials, RemMts),
     subtract_list(Primes, Essentials, NonEss),
     (RemMts = [] -> BestRest = [] ; find_smallest_subset(NonEss, RemMts, BestRest)),
     append(Essentials, BestRest, Total),
-    sort(Total, MinimalCover).
+    sort_unique(Total, MinimalCover).
 
 remaining_minterms([], _, []).
 remaining_minterms([M|Ms], Essentials, Rest) :-

package/examples/rdf12-annotated-claims.pl

@@ -41,7 +41,7 @@ ranked_claims(Claims) :-
     ),
     Unsorted
   ),
-  sort(Unsorted, Sorted),
+  sort_unique(Unsorted, Sorted),
   pair_values(Sorted, Claims).
 
 annotated_status_claim(Status, Source, Score) :-

package/examples/sudoku.pl

@@ -46,7 +46,7 @@ best_choice(Grid, Row, Column, Candidates) :-
     ),
     Choices
   ),
-  sort(Choices, [choice(_Count, Row, Column, Candidates)|_]).
+  sort_unique(Choices, [choice(_Count, Row, Column, Candidates)|_]).
 
 empty_cell(Grid, Row, Column) :-
   between(0, 8, Row),

package/package.json

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

package/playground.html

@@ -655,6 +655,7 @@
             "aggregate_max",
             "aggregate_min",
             "append",
+            "apply",
             "arg",
             "asin",
             "atan2",
@@ -707,7 +708,7 @@
             "sin",
             "slice",
             "smallest_divisor_from",
-            "sort",
+            "sort_unique",
             "split",
             "sqrt",
             "string_concat",
@@ -744,6 +745,7 @@
     let backgroundSource = '';
     let backgroundName = '';
     let activeWorker = null;
+    let activeWorkerStartupTimer = null;
     let renderToken = 0;
     let syntaxErrorLine = null;
     let sourceReference = { kind: 'custom' };
@@ -957,9 +959,29 @@
       runButton.disabled = true;
       stopButton.disabled = false;
 
-      const workerUrl = new URL('./src/playground-worker.js?playground=20260803d', location.href);
+      const workerUrl = new URL('./src/playground-worker.js?playground=20260807b', location.href);
       activeWorker = new Worker(workerUrl, { type: 'module' });
-      activeWorker.onmessage = (event) => finishRun(event.data);
+      const worker = activeWorker;
+      const request = {
+        source: combinedSource(),
+        options: { goals: selectedGoals(), proof: proof.checked, stats: stats.checked },
+      };
+      activeWorkerStartupTimer = setTimeout(() => {
+        if (activeWorker !== worker) return;
+        finishRun({
+          ok: false,
+          error: 'The reasoning worker did not finish loading. Reload the page to refresh cached EyeProlog assets.',
+        });
+      }, 10000);
+      activeWorker.onmessage = (event) => {
+        if (event.data?.type === 'ready') {
+          clearTimeout(activeWorkerStartupTimer);
+          activeWorkerStartupTimer = null;
+          worker.postMessage(request);
+          return;
+        }
+        finishRun(event.data);
+      };
       activeWorker.onerror = (event) => {
         const location = event.filename
           ? ` (${event.filename}${event.lineno ? `:${event.lineno}${event.colno ? `:${event.colno}` : ''}` : ''})`
@@ -974,10 +996,6 @@
         ok: false,
         error: 'The reasoning worker returned an unreadable message.',
       });
-      activeWorker.postMessage({
-        source: combinedSource(),
-        options: { goals: selectedGoals(), proof: proof.checked, stats: stats.checked },
-      });
     }
 
     function combinedSource() {
@@ -1072,6 +1090,8 @@
     }
 
     function cleanupWorker() {
+      if (activeWorkerStartupTimer != null) clearTimeout(activeWorkerStartupTimer);
+      activeWorkerStartupTimer = null;
       if (activeWorker) activeWorker.terminate();
       activeWorker = null;
     }

package/src/cli.js

@@ -115,7 +115,7 @@ async function loadEngine() {
       import('./program.js'),
       import('./solver.js'),
       import('./iso.js'),
-      import('./eyeprolog-library.js'),
+      import('./eyeprolog-autoload.js'),
     ]);
     engineModule = { ...term, ...parser, ...program, ...solver, ...iso, ...library };
   }

package/src/explain.js

@@ -4,7 +4,7 @@
 // human-readable and machine-readable.
 import { ATOM, COMPOUND, Env, Term, VAR, deref, flattenConjunction, freshTerm, termToString, unify, variantTerms } from './term.js';
 import { selectClauseCandidates } from './program.js';
-import { getEyePrologRegistry } from './eyeprolog-library.js';
+import { getEyePrologRegistry } from './eyeprolog-autoload.js';
 import { Solver, nextFreshId } from './solver.js';
 
 export function whyProof(program, goal, options = {}) {

package/src/{eyeprolog-library.js → eyeprolog-autoload.js}

@@ -1,4 +1,4 @@
-// Load and autoload the pure-Prolog EyeProlog library in Node and the browser.
+// Autoload the pure-Prolog EyeProlog library in Node and the browser.
 import { createDefaultRegistry } from './iso.js';
 import { parseClauses } from './parser.js';
 import { fs, isNode } from './platform.js';
@@ -8,7 +8,7 @@ export const eyePrologNativeLibraryIndicators = Object.freeze([]);
 export const eyePrologPortableLibraryIndicators = Object.freeze([
   'uuid/3',
   'difference/3',
-  'call/3',
+  'apply/3',
   'maplist/3',
   'tan/2',
   'asin/2',
@@ -51,7 +51,7 @@ export const eyePrologPortableLibraryIndicators = Object.freeze([
   'min_list/2',
   'max_list/2',
   'list_to_set/2',
-  'sort/2',
+  'sort_unique/2',
   'countall/2',
   'sumall/3',
   'aggregate_min/5',
@@ -64,12 +64,21 @@ export const eyePrologLibraryIndicators = Object.freeze([
 ]);
 
 const autoloadedPrograms = new WeakSet();
-const libraryUrl = new URL('./eyeprolog-library.pl', import.meta.url);
-const librarySource = await loadLibrarySource(libraryUrl);
-const portableClauseTemplates = parseClauses(librarySource, {
-  filename: 'src/eyeprolog-library.pl',
+const libraryFiles = [
+  'eyeprolog-library.pl',
+  'eyeprolog-common-library.pl',
+];
+const libraryCacheKey = isNode
+  ? null
+  : (new URL(import.meta.url).searchParams.get('playground') ?? '20260807b');
+const librarySources = await Promise.all(libraryFiles.map(async (filename) => ({
+  filename,
+  source: await loadLibrarySource(libraryFileUrl(filename)),
+})));
+const portableClauseTemplates = librarySources.flatMap(({ filename, source }) => parseClauses(source, {
+  filename: `src/${filename}`,
   sourceMetadata: true,
-});
+}));
 
 async function loadLibrarySource(url) {
   if (isNode) return fs.readFileSync(url, 'utf8');
@@ -78,6 +87,12 @@ async function loadLibrarySource(url) {
   return response.text();
 }
 
+function libraryFileUrl(filename) {
+  const url = new URL(`./${filename}`, import.meta.url);
+  if (!isNode && libraryCacheKey) url.searchParams.set('playground', libraryCacheKey);
+  return url;
+}
+
 export function ensureEyePrologLibrary(program) {
   if (autoloadedPrograms.has(program)) return program;
 

package/src/eyeprolog-common-library.pl

@@ -0,0 +1,44 @@
+% Common pure-Prolog library predicates for EyeProlog.
+%
+% EyeProlog autoloads this file together with eyeprolog-library.pl. Other
+% Prolog systems should load eyeprolog-library.pl only and use their native or
+% library versions of these widespread predicates, avoiding redefinition of
+% protected procedures.
+
+maplist(_, [], []).
+maplist(Closure, [A|As], [B|Bs]) :-
+    apply(Closure, A, B),
+    maplist(Closure, As, Bs).
+
+append([], Ys, Ys).
+append([X|Xs], Ys, [X|Zs]) :- append(Xs, Ys, Zs).
+
+member(X, [X|_]).
+member(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).
+
+nth1(N, List, X) :- nth0(N0, List, X), N is N0 + 1.
+
+reverse(List, Reversed) :- eyeprolog__reverse(List, [], Reversed).
+
+length(List, Length) :- nonvar(List), eyeprolog__length_count(List, 0, Length).
+length(List, Length) :- var(List), integer(Length), Length >= 0, eyeprolog__length_make(Length, List).
+
+sum_list(List, Sum) :- eyeprolog__sum_list(List, 0, Sum).
+
+min_list([X|Xs], Min) :- eyeprolog__min_list(Xs, X, Min).
+
+max_list([X|Xs], Max) :- eyeprolog__max_list(Xs, X, Max).
+
+list_to_set(List, Set) :- eyeprolog__list_to_set(List, [], Set).
+
+countall(Goal, Count) :- findall(1, Goal, Ones), eyeprolog__length_count(Ones, 0, Count).

package/src/eyeprolog-library.pl

@@ -37,17 +37,18 @@ eyeprolog__atomic_chars(Value, Chars) :-
 
 % ---------- core/meta ----------
 
-call(Closure, A, B) :-
+eyeprolog__append([], Ys, Ys).
+eyeprolog__append([X|Xs], Ys, [X|Zs]) :- eyeprolog__append(Xs, Ys, Zs).
+
+eyeprolog__member(X, [X|_]).
+eyeprolog__member(X, [_|Xs]) :- eyeprolog__member(X, Xs).
+
+apply(Closure, A, B) :-
     Closure =.. Parts,
-    append(Parts, [A, B], CallParts),
+    eyeprolog__append(Parts, [A, B], CallParts),
     Goal =.. CallParts,
     call(Goal).
 
-maplist(_, [], []).
-maplist(Closure, [A|As], [B|Bs]) :-
-    call(Closure, A, B),
-    maplist(Closure, As, Bs).
-
 % ---------- arithmetic helpers ----------
 
 tan(X, Y) :- Y is sin(X) / cos(X).
@@ -86,7 +87,7 @@ eyeprolog__duration_field([C|Cs], [C|Ds], Unit, Rest) :-
     char_code(C, Code), Code >= 48, Code =< 57,
     eyeprolog__duration_field(Cs, Ds, Unit, Rest).
 eyeprolog__duration_field([Unit|Rest], [], Unit, Rest) :-
-    member(Unit, ['Y', 'M', 'D']).
+    eyeprolog__member(Unit, ['Y', 'M', 'D']).
 
 eyeprolog__duration_assign('Y', N, 0, M, D, N, M, D).
 eyeprolog__duration_assign('M', N, Y, 0, D, Y, N, D).
@@ -174,10 +175,10 @@ uuid(Seed0, UUID, Seed) :-
     eyeprolog__hex_digit(VariantValue, Variant),
     eyeprolog__uuid_hex(3, Seed4, Group4, Seed5),
     eyeprolog__uuid_hex(12, Seed5, Group5, Seed),
-    append(Group1, ['-'|Tail1], Chars),
-    append(Group2, ['-','4'|Tail2], Tail1),
-    append(Group3, ['-',Variant|Tail3], Tail2),
-    append(Group4, ['-'|Group5], Tail3),
+    eyeprolog__append(Group1, ['-'|Tail1], Chars),
+    eyeprolog__append(Group2, ['-','4'|Tail2], Tail1),
+    eyeprolog__append(Group3, ['-',Variant|Tail3], Tail2),
+    eyeprolog__append(Group4, ['-'|Group5], Tail3),
     atom_chars(UUID, Chars).
 
 eyeprolog__uuid_hex(0, Seed, [], Seed).
@@ -215,7 +216,7 @@ smallest_divisor_from(N, Start, Divisor) :-
 % in the exact range covered by bases 2,3,5,7,11,13,17. Above that range the
 % implementation falls back to exact trial division, preserving semantics for
 % arbitrary-size integers.
-eyeprolog__smallest_divisor_fast(N, Start, N) :-
+eyeprolog__smallest_divisor_fast(N, _, N) :-
     N >= 2,
     N < 341550071728321,
     eyeprolog__mr_prime(N),
@@ -327,8 +328,8 @@ eyeprolog__previous_month(Y, 1, PY, 12) :- PY is Y - 1.
 
 eyeprolog__days_in_month(Y, 2, 29) :- eyeprolog__leap_year(Y).
 eyeprolog__days_in_month(Y, 2, 28) :- \+ eyeprolog__leap_year(Y).
-eyeprolog__days_in_month(_, M, 30) :- member(M, [4,6,9,11]).
-eyeprolog__days_in_month(_, M, 31) :- member(M, [1,3,5,7,8,10,12]).
+eyeprolog__days_in_month(_, M, 30) :- eyeprolog__member(M, [4,6,9,11]).
+eyeprolog__days_in_month(_, M, 31) :- eyeprolog__member(M, [1,3,5,7,8,10,12]).
 
 eyeprolog__leap_year(Y) :- 0 is Y mod 400.
 eyeprolog__leap_year(Y) :- Y mod 100 =\= 0, 0 is Y mod 4.
@@ -340,15 +341,15 @@ eyeprolog__format_duration(Y, M, D, Duration) :-
     eyeprolog__duration_part(Y, 'Y', YC),
     eyeprolog__duration_part(M, 'M', MC),
     eyeprolog__duration_part(D, 'D', DC),
-    append(['P'|YC], MC, A),
-    append(A, DC, Chars),
+    eyeprolog__append(['P'|YC], MC, A),
+    eyeprolog__append(A, DC, Chars),
     eyeprolog__text_chars(Duration, Chars).
 
 eyeprolog__duration_part(0, _, []).
 eyeprolog__duration_part(N, Unit, Chars) :-
     N =\= 0,
     number_chars(N, Digits),
-    append(Digits, [Unit], Chars).
+    eyeprolog__append(Digits, [Unit], Chars).
 
 % ---------- portable named-capture matcher ----------
 %
@@ -383,8 +384,8 @@ eyeprolog__regex_parse(Chars0, Start, End, Tokens) :-
 eyeprolog__strip_start_anchor(['^'|Cs], yes, Cs).
 eyeprolog__strip_start_anchor(Cs, no, Cs).
 
-eyeprolog__strip_end_anchor(Cs0, yes, Cs) :- append(Cs, ['$'], Cs0).
-eyeprolog__strip_end_anchor(Cs, no, Cs) :- \+ append(_, ['$'], Cs).
+eyeprolog__strip_end_anchor(Cs0, yes, Cs) :- eyeprolog__append(Cs, ['$'], Cs0).
+eyeprolog__strip_end_anchor(Cs, no, Cs) :- \+ eyeprolog__append(_, ['$'], Cs).
 
 eyeprolog__regex_tokens_parse([], []).
 eyeprolog__regex_tokens_parse(['('|Cs], [capture(Name, Kind, Optional)|Tokens]) :-
@@ -425,12 +426,12 @@ eyeprolog__capture_kind(['['|Body], class_exact(Class, Count)) :-
     Class \= [].
 eyeprolog__capture_kind(Body, literal(Body)) :-
     Body \= [],
-    \+ member('(', Body),
-    \+ member(')', Body),
-    \+ member('[', Body),
-    \+ member(']', Body),
-    \+ member('+', Body),
-    \+ member('*', Body).
+    \+ eyeprolog__member('(', Body),
+    \+ eyeprolog__member(')', Body),
+    \+ eyeprolog__member('[', Body),
+    \+ eyeprolog__member(']', Body),
+    \+ eyeprolog__member('+', Body),
+    \+ eyeprolog__member('*', Body).
 
 eyeprolog__has_capture([capture(_,_,_)|_]).
 eyeprolog__has_capture([_|Ts]) :- eyeprolog__has_capture(Ts).
@@ -449,7 +450,7 @@ eyeprolog__regex_tokens([capture(Name,Kind,yes)|Ts], Chars, Rest, [capture(Name,
 eyeprolog__regex_tokens([capture(_,_,yes)|Ts], Chars, Rest, Captures) :-
     eyeprolog__regex_tokens(Ts, Chars, Rest, Captures).
 
-eyeprolog__capture_match(literal(Literal), Chars, Rest, Literal) :- append(Literal, Rest, Chars).
+eyeprolog__capture_match(literal(Literal), Chars, Rest, Literal) :- eyeprolog__append(Literal, Rest, Chars).
 eyeprolog__capture_match(word_plus, Chars, Rest, Value) :- eyeprolog__take_class_plus(word, Chars, Value, Rest).
 eyeprolog__capture_match(nonspace_plus, Chars, Rest, Value) :- eyeprolog__take_class_plus(nonspace, Chars, Value, Rest).
 eyeprolog__capture_match(class_plus(Class), Chars, Rest, Value) :- eyeprolog__take_class_plus(class(Class), Chars, Value, Rest).
@@ -494,33 +495,30 @@ eyeprolog__captures_context([capture(Name,Value)|Rest], (Term,Context)) :-
 
 % ---------- text/list processing ----------
 
-append([], Ys, Ys).
-append([X|Xs], Ys, [X|Zs]) :- append(Xs, Ys, Zs).
-
 string_concat(A, B, Whole) :-
     nonvar(A), nonvar(B),
     !,
     eyeprolog__text_chars(A, AC),
     eyeprolog__text_chars(B, BC),
-    append(AC, BC, WC),
+    eyeprolog__append(AC, BC, WC),
     eyeprolog__text_chars(Whole, WC).
 string_concat(A, B, Whole) :-
     nonvar(Whole),
     eyeprolog__text_chars(Whole, WC),
-    append(AC, BC, WC),
+    eyeprolog__append(AC, BC, WC),
     eyeprolog__text_chars(A, AC),
     eyeprolog__text_chars(B, BC).
 
 contains(Text, Needle) :-
     eyeprolog__text_chars(Text, TextChars),
     eyeprolog__text_chars(Needle, NeedleChars),
-    append(_, Tail, TextChars),
-    append(NeedleChars, _, Tail),
+    eyeprolog__append(_, Tail, TextChars),
+    eyeprolog__append(NeedleChars, _, Tail),
     !.
 
 matches(Text, Pattern) :-
     split(Pattern, '|', Alternatives),
-    member(Needle, Alternatives),
+    eyeprolog__member(Needle, Alternatives),
     contains(Text, Needle),
     !.
 
@@ -533,8 +531,8 @@ split(Text, Separator, Parts) :-
 eyeprolog__split_chars(Chars, [], Parts) :- eyeprolog__split_each_char(Chars, Parts).
 eyeprolog__split_chars(Chars, Separator, [Prefix|Parts]) :-
     Separator \= [],
-    append(Prefix, Tail, Chars),
-    append(Separator, Rest, Tail),
+    eyeprolog__append(Prefix, Tail, Chars),
+    eyeprolog__append(Separator, Rest, Tail),
     !,
     eyeprolog__split_chars(Rest, Separator, Parts).
 eyeprolog__split_chars(Chars, Separator, [Chars]) :- Separator \= [].
@@ -586,9 +584,9 @@ eyeprolog__upper_code(Code, Code) :- (Code < 97 ; Code > 122).
 trim(Text, Trimmed) :-
     eyeprolog__text_chars(Text, Chars),
     eyeprolog__drop_space(Chars, Left),
-    reverse(Left, Reversed),
+    eyeprolog__reverse(Left, [], Reversed),
     eyeprolog__drop_space(Reversed, RightReversed),
-    reverse(RightReversed, TrimmedChars),
+    eyeprolog__reverse(RightReversed, [], TrimmedChars),
     eyeprolog__text_chars(Trimmed, TrimmedChars).
 
 eyeprolog__drop_space([C|Cs], Out) :-
@@ -632,15 +630,15 @@ eyeprolog__term_chars(Term, Chars) :- atom(Term), atom_chars(Term, Chars).
 eyeprolog__term_chars([], ['[',']']).
 eyeprolog__term_chars([H|T], Chars) :-
     eyeprolog__list_term_chars([H|T], Body),
-    append(['['|Body], [']'], Chars).
+    eyeprolog__append(['['|Body], [']'], Chars).
 eyeprolog__term_chars(Term, Chars) :-
     compound(Term),
     Term \= [_|_],
     Term =.. [Name|Args],
     atom_chars(Name, NameChars),
     eyeprolog__term_args_chars(Args, ArgsChars),
-    append(NameChars, ['('|ArgsChars], A),
-    append(A, [')'], Chars).
+    eyeprolog__append(NameChars, ['('|ArgsChars], A),
+    eyeprolog__append(A, [')'], Chars).
 
 eyeprolog__list_term_chars([H], Chars) :-
     eyeprolog__term_chars(H, Chars).
@@ -648,19 +646,19 @@ eyeprolog__list_term_chars([H|T], Chars) :-
     T = [_|_],
     eyeprolog__term_chars(H, HC),
     eyeprolog__list_term_chars(T, TC),
-    append(HC, [',',' '|TC], Chars).
+    eyeprolog__append(HC, [',',' '|TC], Chars).
 eyeprolog__list_term_chars([H|T], Chars) :-
     T \= [], T \= [_|_],
     eyeprolog__term_chars(H, HC),
     eyeprolog__term_chars(T, TC),
-    append(HC, [' ','|',' '|TC], Chars).
+    eyeprolog__append(HC, [' ','|',' '|TC], Chars).
 
 eyeprolog__term_args_chars([A], Chars) :- eyeprolog__term_chars(A, Chars).
 eyeprolog__term_args_chars([A|As], Chars) :-
     As \= [],
     eyeprolog__term_chars(A, AC),
     eyeprolog__term_args_chars(As, Rest),
-    append(AC, [',',' '|Rest], Chars).
+    eyeprolog__append(AC, [',',' '|Rest], Chars).
 
 join([], _, Out) :- eyeprolog__text_chars(Out, []).
 join([Item|Items], Separator, Out) :-
@@ -672,8 +670,8 @@ join([Item|Items], Separator, Out) :-
 eyeprolog__join_chars([], _, Chars, Chars).
 eyeprolog__join_chars([Item|Items], Separator, Prefix, Out) :-
     eyeprolog__atomic_chars(Item, ItemChars),
-    append(Prefix, Separator, A),
-    append(A, ItemChars, B),
+    eyeprolog__append(Prefix, Separator, A),
+    eyeprolog__append(A, ItemChars, B),
     eyeprolog__join_chars(Items, Separator, B, Out).
 
 substring(Text, Start, Count, Out) :-
@@ -685,21 +683,6 @@ substring(Text, Start, Count, Out) :-
 
 % ---------- list relations ----------
 
-member(X, [X|_]).
-member(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).
-
-nth1(N, List, X) :- nth0(N0, List, X), N is N0 + 1.
-
 set_nth0(0, [_|Xs], X, [X|Xs]).
 set_nth0(N, [Y|Ys], X, [Y|Zs]) :- N > 0, N1 is N - 1, set_nth0(N1, Ys, X, Zs).
 
@@ -711,33 +694,25 @@ drop(N, [_|Xs], Ys) :- N > 0, N1 is N - 1, drop(N1, Xs, Ys).
 
 slice(Start, Count, List, Slice) :- drop(Start, List, Tail), take(Count, Tail, Slice).
 
-reverse(List, Reversed) :- eyeprolog__reverse(List, [], Reversed).
 eyeprolog__reverse([], Acc, Acc).
 eyeprolog__reverse([X|Xs], Acc, Out) :- eyeprolog__reverse(Xs, [X|Acc], Out).
 
-length(List, Length) :- nonvar(List), eyeprolog__length_count(List, 0, Length).
-length(List, Length) :- var(List), integer(Length), Length >= 0, eyeprolog__length_make(Length, List).
-
 eyeprolog__length_count([], N, N).
 eyeprolog__length_count([_|Xs], N0, N) :- N1 is N0 + 1, eyeprolog__length_count(Xs, N1, N).
 eyeprolog__length_make(0, []).
 eyeprolog__length_make(N, [_|Xs]) :- N > 0, N1 is N - 1, eyeprolog__length_make(N1, Xs).
 
-sum_list(List, Sum) :- eyeprolog__sum_list(List, 0, Sum).
 eyeprolog__sum_list([], Sum, Sum).
 eyeprolog__sum_list([X|Xs], Acc, Sum) :- Next is Acc + X, eyeprolog__sum_list(Xs, Next, Sum).
 
-min_list([X|Xs], Min) :- eyeprolog__min_list(Xs, X, Min).
 eyeprolog__min_list([], Min, Min).
 eyeprolog__min_list([X|Xs], Current, Min) :- X @< Current, eyeprolog__min_list(Xs, X, Min).
 eyeprolog__min_list([X|Xs], Current, Min) :- X @>= Current, eyeprolog__min_list(Xs, Current, Min).
 
-max_list([X|Xs], Max) :- eyeprolog__max_list(Xs, X, Max).
 eyeprolog__max_list([], Max, Max).
 eyeprolog__max_list([X|Xs], Current, Max) :- X @> Current, eyeprolog__max_list(Xs, X, Max).
 eyeprolog__max_list([X|Xs], Current, Max) :- X @=< Current, eyeprolog__max_list(Xs, Current, Max).
 
-list_to_set(List, Set) :- eyeprolog__list_to_set(List, [], Set).
 eyeprolog__list_to_set([], _, []).
 eyeprolog__list_to_set([X|Xs], Seen, Set) :-
     eyeprolog__identical_member(X, Seen),
@@ -749,7 +724,7 @@ eyeprolog__list_to_set([X|Xs], Seen, [X|Set]) :-
 eyeprolog__identical_member(X, [Y|_]) :- X == Y.
 eyeprolog__identical_member(X, [_|Ys]) :- eyeprolog__identical_member(X, Ys).
 
-sort(List, Sorted) :- eyeprolog__sort(List, [], Sorted).
+sort_unique(List, Sorted) :- eyeprolog__sort(List, [], Sorted).
 eyeprolog__sort([], Sorted, Sorted).
 eyeprolog__sort([X|Xs], Acc, Sorted) :-
     eyeprolog__insert_sorted(X, Acc, Next),
@@ -762,11 +737,9 @@ eyeprolog__insert_sorted(X, [Y|Ys], [Y|Zs]) :- X @> Y, eyeprolog__insert_sorted(
 
 % ---------- aggregation ----------
 
-countall(Goal, Count) :- findall(1, Goal, Ones), length(Ones, Count).
-
 sumall(Expression, Goal, Sum) :-
     findall(Value, (Goal, Value is Expression), Values),
-    sum_list(Values, Sum).
+    eyeprolog__sum_list(Values, 0, Sum).
 
 aggregate_min(Key, Value, Goal, BestKey, BestValue) :-
     findall(pair(Key, Value), Goal, Pairs),
@@ -775,7 +748,7 @@ aggregate_min(Key, Value, Goal, BestKey, BestValue) :-
 eyeprolog__aggregate_min([pair(K,V)|Pairs], BestKey, BestValue) :-
     eyeprolog__aggregate_min_rest(Pairs, K, V, BestKey, BestValue).
 eyeprolog__aggregate_min_rest([], K, V, K, V).
-eyeprolog__aggregate_min_rest([pair(K,V)|Pairs], CK, CV, BK, BV) :-
+eyeprolog__aggregate_min_rest([pair(K,V)|Pairs], CK, _, BK, BV) :-
     K @< CK,
     eyeprolog__aggregate_min_rest(Pairs, K, V, BK, BV).
 eyeprolog__aggregate_min_rest([pair(K,_)|Pairs], CK, CV, BK, BV) :-
@@ -789,7 +762,7 @@ aggregate_max(Key, Value, Goal, BestKey, BestValue) :-
 eyeprolog__aggregate_max([pair(K,V)|Pairs], BestKey, BestValue) :-
     eyeprolog__aggregate_max_rest(Pairs, K, V, BestKey, BestValue).
 eyeprolog__aggregate_max_rest([], K, V, K, V).
-eyeprolog__aggregate_max_rest([pair(K,V)|Pairs], CK, CV, BK, BV) :-
+eyeprolog__aggregate_max_rest([pair(K,V)|Pairs], CK, _, BK, BV) :-
     K @> CK,
     eyeprolog__aggregate_max_rest(Pairs, K, V, BK, BV).
 eyeprolog__aggregate_max_rest([pair(K,_)|Pairs], CK, CV, BK, BV) :-

package/src/index.js

@@ -18,7 +18,7 @@ export {
   eyePrologLibraryIndicators,
   eyePrologNativeLibraryIndicators,
   eyePrologPortableLibraryIndicators,
-} from './eyeprolog-library.js';
+} from './eyeprolog-autoload.js';
 export { StreamManager } from './io.js';
 
 import { ATOM, COMPOUND, VAR, Env, copyResolved, termIsGround, termToString } from './term.js';
@@ -26,7 +26,7 @@ import { Program } from './program.js';
 import { Solver } from './solver.js';
 import { whyNoProof, whyProof } from './explain.js';
 import { HaltSignal, PrologError } from './iso.js';
-import { getEyePrologRegistry } from './eyeprolog-library.js';
+import { getEyePrologRegistry } from './eyeprolog-autoload.js';
 import { parseGoalText } from './parser.js';
 
 export function run(source, options = {}) {

package/src/playground-worker.js

@@ -1,8 +1,7 @@
 // Browser worker entry used by playground.html.
 // Keep this module free of Node-only imports: it is fetched directly by the
 // browser and is also exercised by test/run-playground.mjs.
-import { run } from './index.js?playground=20260803c';
-import { createEyePrologRegistry } from './eyeprolog-library.js?playground=20260803c';
+import { createEyePrologRegistry, run } from './index.js?playground=20260807b';
 
 const registry = createEyePrologRegistry();
 
@@ -42,4 +41,5 @@ function defaultNow() {
 
 if (typeof self !== 'undefined' && typeof self.postMessage === 'function') {
   installPlaygroundWorker(self);
+  self.postMessage({ type: 'ready' });
 }

package/src/solver.js

@@ -5,7 +5,7 @@ import {
   numberTerm, numberTextFromDouble, termIsGround, termToString, unify, variantTerms,
 } from './term.js';
 import { PrologError } from './iso.js';
-import { ensureEyePrologLibrary, getEyePrologRegistry } from './eyeprolog-library.js';
+import { ensureEyePrologLibrary, getEyePrologRegistry } from './eyeprolog-autoload.js';
 import { selectClauseCandidates, selectClauseCandidatesForValues, selectGroundClauseCandidates } from './program.js';
 import { StreamManager } from './io.js';
 

package/test/conformance/cases/lists/031_lists_aggregation_ordering.pl

@@ -6,6 +6,5 @@ answer(set_nth0, X) :- set_nth0(1, [a, b, c], x, X).
 answer(reverse, X) :- reverse([a, b, c], X).
 answer(length, N) :- length([a, b, c], N).
 answer(findall, X) :- findall(N, between(1, 3, N), X).
-answer(sort, X) :- sort([b, a, b], X).
+answer(sort, X) :- sort_unique([b, a, b], X).
 %% goal: answer(X0, X1)
-

package/test/conformance/cases/lists/045_sort_deduplicates_atoms.pl

@@ -1,4 +1,3 @@
-% Reference 9.8: sort/2 sorts and deduplicates a proper list.
-answer(sorted, X) :- sort([c, a, b, a], X).
+% Reference 9.8: sort_unique/2 sorts and deduplicates a proper list.
+answer(sorted, X) :- sort_unique([c, a, b, a], X).
 %% goal: answer(X0, X1)
-

package/test/conformance/cases/lists/087_sort_reverse_length.pl

@@ -4,6 +4,6 @@
 answer(length_empty, X) :- length([], X).
 answer(length_nested, X) :- length([[a], [b, c], []], X).
 answer(reverse_atoms, X) :- reverse([a, b, c], X).
-answer(sort_numbers, X) :- sort([3, 1, 2, 1], X).
-answer(sort_mixed_terms, X) :- sort([b, 2, a, 1, pair(a), "s"], X).
+answer(sort_numbers, X) :- sort_unique([3, 1, 2, 1], X).
+answer(sort_mixed_terms, X) :- sort_unique([b, 2, a, 1, pair(a), "s"], X).
 answer(reverse_empty, X) :- reverse([], X).

package/test/conformance/cases/lists/extra_sort_iri_atoms.pl

@@ -1,3 +1,3 @@
 %% goal: answer(X0, X1)
 
-answer(sort_iri_atoms, X) :- sort(['<urn:example:b>', '<urn:example:a>'], X).
+answer(sort_iri_atoms, X) :- sort_unique(['<urn:example:b>', '<urn:example:a>'], X).

package/test/conformance/cases/lists/sort_structured_terms.pl

@@ -1,3 +1,3 @@
 %% goal: answer(X0)
 
-answer(X) :- sort([b(2), a(3), a(1)], X).
+answer(X) :- sort_unique([b(2), a(3), a(1)], X).

package/test/run-playground.mjs

@@ -22,6 +22,8 @@ export async function runPlayground(reporter = new TestReporter()) {
     const html = fs.readFileSync(path.join(packageRoot, 'playground.html'), 'utf8');
     assertIncludes(html, "new URL('./src/playground-worker.js?playground=", 'playground worker URL');
     assertIncludes(html, "new Worker(workerUrl, { type: 'module' })", 'module worker construction');
+    assertIncludes(html, "event.data?.type === 'ready'", 'worker readiness handshake');
+    assertIncludes(html, 'did not finish loading', 'worker startup timeout');
     assertNotIncludes(html, 'URL.createObjectURL(new Blob([workerCode]', 'inline blob worker');
   });
 
@@ -80,6 +82,8 @@ export async function runPlayground(reporter = new TestReporter()) {
         ['playground.html', 'text/html'],
         ['src/playground-worker.js', 'text/javascript'],
         ['src/index.js', 'text/javascript'],
+        ['src/eyeprolog-library.pl', 'text/plain'],
+        ['src/eyeprolog-common-library.pl', 'text/plain'],
         ['examples/socrates.pl', 'text/plain'],
       ];
       for (const [relative, contentType] of expected) {
@@ -94,7 +98,7 @@ export async function runPlayground(reporter = new TestReporter()) {
     await withStaticServer(async (baseUrl) => {
       const modules = await crawlModuleGraph(new URL('src/playground-worker.js?playground=test', baseUrl));
       assert(modules.size >= 10, `expected a substantial worker module graph, got ${modules.size}`);
-      assert([...modules].some((url) => url.includes('/src/eyeprolog-library.js')), 'EyeProlog library missing from worker graph');
+      assert([...modules].some((url) => url.includes('/src/eyeprolog-autoload.js')), 'EyeProlog autoloader missing from worker graph');
       assert([...modules].some((url) => url.includes('/src/solver.js')), 'solver missing from worker graph');
     });
   });

package/test/run-regression.mjs

@@ -584,7 +584,7 @@ function documentationSyncCases() {
           '[Book — *The Art of EyeProlog*](https://eyereasoner.github.io/eyeprolog/the-art-of-eyeprolog)',
           'README links to the book',
         );
-        for (const filename of ['src/iso.js', 'src/eyeprolog-library.js', 'src/playground-worker.js']) {
+        for (const filename of ['src/iso.js', 'src/eyeprolog-autoload.js', 'src/playground-worker.js']) {
           assertEqual(fs.existsSync(path.join(packageRoot, filename)), true, `${filename} exists`);
           assertIncludes(book, filename, `book documents ${filename}`);
         }
@@ -1047,7 +1047,8 @@ open(X) :- candidate(X), \\+ closed(X).
         assertEqual(betweenGenerator.cutRecursive, true, 'portable between generator has deterministic recursive control');
         assertEqual(betweenGenerator.tabled, false, 'portable between generator avoids suffix answer tables');
         assertEqual(fs.existsSync(path.join(packageRoot, 'src', 'eyeprolog-library.pl')), true, 'portable Prolog source exists');
-        assertEqual(fs.existsSync(path.join(packageRoot, 'src', 'eyeprolog-library.js')), true, 'portable source loader exists');
+        assertEqual(fs.existsSync(path.join(packageRoot, 'src', 'eyeprolog-autoload.js')), true, 'portable source autoloader exists');
+        assertEqual(fs.existsSync(path.join(packageRoot, 'src', 'eyeprolog-common-library.pl')), true, 'pure-Prolog common library exists');
         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');
         assertEqual(run(program, { goal: 'answer(X)' }).stdout, 'answer([a, b]).\n', 'autoloaded append execution');
@@ -1058,7 +1059,9 @@ open(X) :- candidate(X), \\+ closed(X).
       name: 'portable library executes against the ISO-only registry',
       run: () => {
         const portableSource = fs.readFileSync(path.join(packageRoot, 'src', 'eyeprolog-library.pl'), 'utf8');
+        const commonSource = fs.readFileSync(path.join(packageRoot, 'src', 'eyeprolog-common-library.pl'), 'utf8');
         const program = Program.parse(`${portableSource}
+${commonSource}
 portable_check(A, B, C) :- lowercase('HELLO', A), replace('banana', 'na', 'NA', B), append([x], [y], C).
 `);
         const solver = new Solver(program, { registry: createDefaultRegistry() });
@@ -1712,7 +1715,7 @@ function playgroundStaticIssues() {
   if (!html.includes("new URL('./src/playground-worker.js?playground=")) issues.push('playground must cache-bust its dedicated module worker');
   if (!html.includes("new Worker(workerUrl, { type: 'module' })")) issues.push('playground must launch the dedicated module worker');
   const workerText = fs.readFileSync(path.join(packageRoot, 'src', 'playground-worker.js'), 'utf8');
-  if (!workerText.includes("from './eyeprolog-library.js?playground=") ||
+if (!workerText.includes("from './index.js?playground=") ||
       !workerText.includes('createEyePrologRegistry') ||
       !workerText.includes('executePlaygroundRequest')) {
     issues.push('playground worker must install the EyeProlog library registry');

package/the-art-of-eyeprolog.md

@@ -907,7 +907,7 @@ reverse_go([X | Xs], Acc, Reversed) :-
 
 No mutation occurs; every call receives a new term. EyeProlog also includes
 `member/2`, `append/3`, `select/3`, `nth0/3`, `reverse/2`, `length/2`,
-`sort/2`, slicing helpers, and numeric summaries. Improper lists such as
+`sort_unique/2`, slicing helpers, and numeric summaries. Improper lists such as
 `[a | Tail]` are valid terms, but operations requiring a proper finite list
 fail unless the tail is `[]`.
 
@@ -1109,7 +1109,7 @@ Choose a collector from the question, not from convenience:
 Counting solutions is not necessarily counting distinct domain objects: two
 proofs may resolve the visible value in the same way. When identity matters,
 collect the identifying template and deliberately canonicalize it with
-`sort/2`; when derivation multiplicity matters, retain the duplicates. Making
+`sort_unique/2`; when derivation multiplicity matters, retain the duplicates. Making
 that decision explicit prevents a database-style summary from silently
 changing the question.
 
@@ -1709,11 +1709,12 @@ truncate search; it does not prove that no further answer exists.
 ### Implementation boundary
 
 The source layout mirrors the language boundary. `src/iso.js` contains the
-isolated ISO processor predicates and registry. `src/eyeprolog-library.pl` is
-the portable EyeProlog library: 50 public predicates written as ordinary
-Prolog clauses against that ISO profile. Its paired
-`src/eyeprolog-library.js` module loads the Prolog file in Node and the browser
-and owns the small autoload integration layer.
+isolated ISO processor predicates and registry. `src/eyeprolog-library.pl`
+contains collision-free, self-contained portable extensions.
+`src/eyeprolog-common-library.pl` supplies common list and aggregation
+predicates that Trealla, Scryer, and many other systems already provide. The
+paired `src/eyeprolog-autoload.js` module autoloads both pure-Prolog files in
+Node and the browser.
 The RDF tools emit IRI and literal lexical values as ISO atoms, matching the
 portable text API without a host representation adapter.
 
@@ -5254,14 +5255,17 @@ so side effects occur in Prolog execution order.
 
 EyeProlog exposes **50 library predicate indicators** in addition to the 115
 indicators in its isolated ISO profile. **All 50 are ordinary Prolog clauses**
-in `src/eyeprolog-library.pl`; none is a native host predicate. The resulting
+across `src/eyeprolog-library.pl` and `src/eyeprolog-common-library.pl`; none
+is a native host predicate. The resulting
 normal EyeProlog language surface is therefore **165 public predicate
 indicators**. Internally, the runtime registry contains only the 115 ISO
 definitions; the EyeProlog relations are autoloaded source clauses.
 
-The portable file is autoloaded once into every `Program` used with the
-EyeProlog registry. `src/eyeprolog-library.js` loads it from the package in Node
-or through `fetch()` in the browser and performs the autoload.
+The two Prolog files are autoloaded once into every `Program` used with the
+EyeProlog registry. `src/eyeprolog-autoload.js` loads them from the package in
+Node or through `fetch()` in the browser and performs the autoload. External
+Prolog systems load only `src/eyeprolog-library.pl`; this avoids redefining
+their protected or preloaded list predicates.
 The isolated ISO-only registry remains
 available through `createDefaultRegistry()` and `getDefaultRegistry()` for
 conformance work and advanced embedders. Source clauses sharing a portable
@@ -5276,18 +5280,18 @@ standard fallback relation.
 | `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`, `sort/2` |
+| `list_to_set/2`, `sort_unique/2` |
 | `string_concat/3`, `contains/2`, `matches/2` |
 | `join/3`, `substring/4` |
 | `countall/2`, `sumall/3` |
 | `aggregate_min/5`, `aggregate_max/5` |
 | `between/3`, `smallest_divisor_from/3`, `random/3` |
+| `apply/3` |
 | `maplist/3` |
 | `acos/2`, `asin/2`, `atan2/3`, `tan/2` |
 | `lt/2`, `le/2`, `gt/2`, `ge/2` |
 | `uuid/3`, `difference/3` |
 | `matches/3` |
-| `call/3` |
 | `split/3`, `replace/4` |
 | `lowercase/2`, `uppercase/2`, `trim/2` |
 | `number_string/2`, `atom_string/2`, `term_string/2` |
@@ -5374,7 +5378,8 @@ zero-based, nonnegative safe integers.
 | `\+ member(+Item,+List)` | Succeeds only when `Item` does not unify with any member. Use it after binding the item and list. |
 | `nth0(?Index,+List,?Item)` | Checks a bound zero-based index or enumerates indexes and their items. |
 | `nth1(?Index,+List,?Item)` | Checks a bound one-based index or enumerates one-based indexes and items. |
-| `maplist(+Closure,+List1,?List2)` | Applies a two-argument closure pairwise; `call/3` supplies the closure arguments and supports partially applied compound closures. |
+| `apply(+Closure,+A,+B)` | Extends a closure with two arguments using ISO `=../2`, then invokes it through ISO `call/1`. |
+| `maplist(+Closure,+List1,?List2)` | Applies a two-argument closure pairwise through `apply/3`; partially applied compound closures are supported. |
 | `[Head|Tail] = List` | Decomposes a nonempty list directly with ISO unification; no library wrapper is needed. |
 | `set_nth0(+Index,+List,+Item,-NewList)` | Replaces one existing position without mutating the input list. |
 | `last(+List,?Last)` | Returns the final element of a nonempty proper list. |
@@ -5385,7 +5390,7 @@ zero-based, nonnegative safe integers.
 | `sum_list(+List,-Sum)` | Sums numeric elements with ISO `is/2`. The empty sum is `0`; invalid arithmetic raises the corresponding ISO error. |
 | `min_list(+List,-Min)`, `max_list(+List,-Max)` | Select by EyeProlog term order, not numeric coercion. Empty lists fail. |
 | `list_to_set(+List,-Set)` | Removes later structural duplicates while preserving first-occurrence order. |
-| `sort(+List,-Set)` | Sorts by standard term order and removes structural duplicates. |
+| `sort_unique(+List,-Set)` | Sorts by standard term order and removes structural duplicates without colliding with engines that protect `sort/2`. |
 
 ```eyeprolog
 answer(split, pair(Prefix, Suffix)) :-
@@ -5739,7 +5744,7 @@ mode at a time.
 
 | Program | Standard facility | Checked answer |
 | --- | --- | --- |
-| [Combinatorics Findall Sort](https://github.com/eyereasoner/eyeprolog/blob/main/examples/combinatorics-findall-sort.pl) | Eyelet-inspired combinations example using findall/3 and sort/2. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/combinatorics-findall-sort.pl) |
+| [Combinatorics Findall Sort](https://github.com/eyereasoner/eyeprolog/blob/main/examples/combinatorics-findall-sort.pl) | Eyelet-inspired combinations example using findall/3 and `sort_unique/2`. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/combinatorics-findall-sort.pl) |
 | [Floating Point](https://github.com/eyereasoner/eyeprolog/blob/main/examples/floating-point.pl) | Floating-point arithmetic and comparisons. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/floating-point.pl) · [proof](https://github.com/eyereasoner/eyeprolog/blob/main/examples/proof/floating-point.pl) |
 | [Atomic conversion](https://github.com/eyereasoner/eyeprolog/blob/main/examples/iso-atomic-conversion.pl) | Atom splitting, character atoms, Unicode codes, and numeric parsing. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/iso-atomic-conversion.pl) |
 | [Control and errors](https://github.com/eyereasoner/eyeprolog/blob/main/examples/iso-control-and-errors.pl) | `call/1`, `once/1`, cut, if-then-else, `throw/1`, and `catch/3`. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/iso-control-and-errors.pl) |
@@ -5817,7 +5822,7 @@ finite search space, and which constraint removes which branches?
 
 | Program | Search design | Checked answer |
 | --- | --- | --- |
-| [Dijkstra Findall Sort](https://github.com/eyereasoner/eyeprolog/blob/main/examples/dijkstra-findall-sort.pl) | Eyelet-inspired Dijkstra example using findall/3 and sort/2. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/dijkstra-findall-sort.pl) |
+| [Dijkstra Findall Sort](https://github.com/eyereasoner/eyeprolog/blob/main/examples/dijkstra-findall-sort.pl) | Eyelet-inspired Dijkstra example using findall/3 and `sort_unique/2`. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/dijkstra-findall-sort.pl) |
 | [Dijkstra](https://github.com/eyereasoner/eyeprolog/blob/main/examples/dijkstra.pl) | Weighted path enumeration adapted from Eyeling dijkstra.n3. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/dijkstra.pl) |
 | [DONALD + GERALD = ROBERT](https://github.com/eyereasoner/eyeprolog/blob/main/examples/donald-gerald-robert.pl) | All ten decimal digits are assigned to ten distinct letters. Right-to-left carry propagation cuts a naive 10! search space to one solution. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/donald-gerald-robert.pl) |
 | [Enigma1225](https://github.com/eyereasoner/eyeprolog/blob/main/examples/enigma1225.pl) | New Scientist Enigma 1225, retaining the best board in one pass with `aggregate_max/5`. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/enigma1225.pl) |