eyeprolog 0.5.11 → 0.5.13

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

@@ -3,8 +3,8 @@
 % This file is autoloaded for the EyeProlog runtime and is intentionally
 % written against the project's ISO compatibility profile.  Text-facing
 % predicates accept ISO atoms or proper lists of one-character atoms; newly
-% produced text defaults to atoms.  Only uuid/1 and local_time/1 remain native
-% host built-ins because ISO Prolog has no entropy or wall-clock primitive.
+% produced text defaults to atoms. Every public predicate in this file uses
+% only the project's ISO Prolog profile; none requires host support.
 
 % ---------- text representation helpers ----------
 
@@ -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).
@@ -140,6 +141,72 @@ eyeprolog__between(Low, High, Value) :-
     !,
     eyeprolog__between(Next, High, Value).
 
+% A Park-Miller generator with explicit state. Threading Seed into the next
+% call makes a sequence reproducible without mutable runtime state. Schrage's
+% method keeps every intermediate integer within the exact 32-bit range.
+random(Seed0, Value, Seed) :-
+    integer(Seed0),
+    eyeprolog__random_normalize_seed(Seed0, Normalized),
+    High is Normalized // 44488,
+    Low is Normalized mod 44488,
+    Candidate is 48271 * Low - 3399 * High,
+    eyeprolog__random_wrap(Candidate, Seed),
+    Value is (Seed - 1) / 2147483646.
+
+eyeprolog__random_normalize_seed(Seed, 1) :-
+    0 is Seed mod 2147483647,
+    !.
+eyeprolog__random_normalize_seed(Seed, Normalized) :-
+    Normalized is Seed mod 2147483647.
+
+eyeprolog__random_wrap(Candidate, Candidate) :- Candidate > 0, !.
+eyeprolog__random_wrap(Candidate, Seed) :- Seed is Candidate + 2147483647.
+
+% Seed-threaded UUID version 4 generation. The version and variant nibbles are
+% fixed by RFC 9562; all other nibbles come from random/3. Reusing Seed0
+% reproduces the same UUID, while threading Seed produces a deterministic
+% sequence of different UUIDs.
+uuid(Seed0, UUID, Seed) :-
+    eyeprolog__uuid_hex(8, Seed0, Group1, Seed1),
+    eyeprolog__uuid_hex(4, Seed1, Group2, Seed2),
+    eyeprolog__uuid_hex(3, Seed2, Group3, Seed3),
+    random(Seed3, _, Seed4),
+    VariantValue is 8 + Seed4 mod 4,
+    eyeprolog__hex_digit(VariantValue, Variant),
+    eyeprolog__uuid_hex(3, Seed4, Group4, Seed5),
+    eyeprolog__uuid_hex(12, Seed5, Group5, Seed),
+    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).
+eyeprolog__uuid_hex(Count, Seed0, [Digit|Digits], Seed) :-
+    Count > 0,
+    random(Seed0, _, Seed1),
+    Value is Seed1 mod 16,
+    eyeprolog__hex_digit(Value, Digit),
+    NextCount is Count - 1,
+    eyeprolog__uuid_hex(NextCount, Seed1, Digits, Seed).
+
+eyeprolog__hex_digit(0, '0').
+eyeprolog__hex_digit(1, '1').
+eyeprolog__hex_digit(2, '2').
+eyeprolog__hex_digit(3, '3').
+eyeprolog__hex_digit(4, '4').
+eyeprolog__hex_digit(5, '5').
+eyeprolog__hex_digit(6, '6').
+eyeprolog__hex_digit(7, '7').
+eyeprolog__hex_digit(8, '8').
+eyeprolog__hex_digit(9, '9').
+eyeprolog__hex_digit(10, a).
+eyeprolog__hex_digit(11, b).
+eyeprolog__hex_digit(12, c).
+eyeprolog__hex_digit(13, d).
+eyeprolog__hex_digit(14, e).
+eyeprolog__hex_digit(15, f).
+
 smallest_divisor_from(N, Start, Divisor) :-
     N >= 0,
     Start > 0,
@@ -149,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),
@@ -261,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.
@@ -274,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 ----------
 %
@@ -317,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]) :-
@@ -359,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).
@@ -383,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).
@@ -428,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),
     !.
 
@@ -467,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 \= [].
@@ -520,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) :-
@@ -566,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).
@@ -582,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) :-
@@ -606,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) :-
@@ -619,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).
 
@@ -645,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),
@@ -683,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),
@@ -696,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),
@@ -709,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) :-
@@ -723,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 './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 './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 './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 './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/builtins/extra_uuid_v4.pl

@@ -1,6 +1,6 @@
-% uuid/1 is deterministic and creates a canonical version 4 UUID atom.
+% uuid/3 deterministically creates a canonical version 4 UUID atom from a seed.
 answer(uuid_v4, true) :-
-  uuid(UUID),
+  uuid(1, UUID, _),
   atom(UUID),
   atom_length(UUID, 36),
   sub_atom(UUID, 8, 1, 27, '-'),

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-examples.mjs

@@ -14,7 +14,6 @@ const packageRoot = path.resolve(root, '..');
 const examplesDir = path.join(packageRoot, 'examples');
 const expectedDir = path.join(examplesDir, 'output');
 const expectedProofDir = path.join(examplesDir, 'proof');
-const fixedExampleDate = '2026-05-30';
 
 export const proofExamples = [
   'access-control-policy.pl',
@@ -124,25 +123,18 @@ function runProofExample(name) {
 }
 
 function runProgramExample(programFile, filename, options) {
-  const oldLocalTime = process.env.EYEPROLOG_LOCAL_TIME;
-  process.env.EYEPROLOG_LOCAL_TIME = fixedExampleDate;
+  const text = fs.readFileSync(programFile, 'utf8');
+  const expectedExit = text.match(/^%\s*expect-exit:\s*(\d+)\s*$/m);
+  const program = Program.parseSources([{ text, filename }], {
+    sourceMetadata: options.proof,
+  });
   try {
-    const text = fs.readFileSync(programFile, 'utf8');
-    const expectedExit = text.match(/^%\s*expect-exit:\s*(\d+)\s*$/m);
-    const program = Program.parseSources([{ text, filename }], {
-      sourceMetadata: options.proof,
-    });
-    try {
-      const result = run(program, { ...options, goals: goalsInProgramOrder(program, text) });
-      if (expectedExit) throw new Error(`${filename} expected exit ${expectedExit[1]}, but reasoning succeeded`);
-      return result.stdout;
-    } catch (error) {
-      if (expectedExit && error?.code === Number(expectedExit[1])) return error.stdout ?? '';
-      throw error;
-    }
-  } finally {
-    if (oldLocalTime == null) delete process.env.EYEPROLOG_LOCAL_TIME;
-    else process.env.EYEPROLOG_LOCAL_TIME = oldLocalTime;
+    const result = run(program, { ...options, goals: goalsInProgramOrder(program, text) });
+    if (expectedExit) throw new Error(`${filename} expected exit ${expectedExit[1]}, but reasoning succeeded`);
+    return result.stdout;
+  } catch (error) {
+    if (expectedExit && error?.code === Number(expectedExit[1])) return error.stdout ?? '';
+    throw error;
   }
 }
 

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/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');
     });
   });