eyeprolog 0.5.11 → 0.5.13

package/test/run-regression.mjs

@@ -177,15 +177,23 @@ why(
       },
     },
     {
-      name: 'EYEPROLOG_LOCAL_TIME fixes local_time builtin',
+      name: 'seeded random/3 sequence is reproducible',
       run: () => {
-        const result = runCli(['--goal', 'local_time_answer(D)', '-'], {
-          input: 'local_time_answer(D) :- local_time(D).\n',
-          env: { EYEPROLOG_LOCAL_TIME: '2024-01-02' },
-        });
-        assertEqual(result.status, 0, 'exit status');
-        assertEqual(result.stdout, "local_time_answer('2024-01-02').\n", 'stdout');
-        assertEqual(result.stderr, '', 'stderr');
+        const result = run(
+          'seeded(A, B, C, Seeds) :- random(1, A, S1), random(S1, B, S2), random(1, C, S3), Seeds = [S1, S2, S3].\n',
+          { goal: 'seeded(A, B, C, Seeds)' },
+        );
+        assertEqual(result.stdout, 'seeded(0.00002247747035927835, 0.085032448717423201, 0.00002247747035927835, [48271, 182605794, 48271]).\n', 'stdout');
+      },
+    },
+    {
+      name: 'seeded uuid/3 sequence is reproducible',
+      run: () => {
+        const result = run(
+          'seeded_uuid(U1, U2, true) :- uuid(1, U1, S1), uuid(1, U1, _), uuid(S1, U2, _), U1 \\= U2.\n',
+          { goal: 'seeded_uuid(U1, U2, Same)' },
+        );
+        assertEqual(result.stdout, "seeded_uuid('f26d1319-3f3f-4bd9-b92f-f414794a43b5', '4be874d3-166b-4107-b0dc-9c53074b3de1', true).\n", 'stdout');
       },
     },
     {
@@ -576,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/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}`);
         }
@@ -1007,19 +1015,21 @@ open(X) :- candidate(X), \\+ closed(X).
         assertEqual(Boolean(registry.get('is', 2)), true, 'ISO is/2 exists');
         assertEqual(Boolean(registry.get('append', 3)), false, 'append/3 is not ISO core');
         assertEqual(library.eyePrologLibrary, true, 'complete registry marker');
-        assertEqual(library.defs.size, 117, 'ISO plus host registry size');
-        assertEqual(registeredNativeEyePrologLibraryNames().length, 2, 'public native EyeProlog builtin count');
-        assertEqual(eyePrologPortableLibraryIndicators.length, 48, 'portable Prolog library count');
-        assertEqual(eyePrologNativeLibraryIndicators.length, 2, 'native host library count');
-        assertEqual(eyePrologNativeLibraryIndicators.join(','), 'uuid/1,local_time/1', 'native host library stays minimal');
+        assertEqual(library.defs.size, 115, 'EyeProlog registry contains only ISO host definitions');
+        assertEqual(registeredNativeEyePrologLibraryNames().length, 0, 'public native EyeProlog builtin count');
+        assertEqual(eyePrologPortableLibraryIndicators.length, 50, '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, 50, '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');
+        assertEqual(library.get('local_time', 1), null, 'local_time/1 is not a host builtin');
         assertEqual(library.get('eyeprolog__string_atom', 2), null, 'private string adapter is absent');
         assertEqual(library.get('append', 3), null, 'append/3 moved to portable Prolog');
         assertEqual(library.get('maplist', 3), null, 'maplist/3 moved to portable Prolog');
         assertEqual(library.get('matches', 3), null, 'matches/3 moved to portable Prolog');
-        assertEqual(library.get('uuid', 1)?.deterministic, true, 'uuid/1 deterministic metadata');
+        assertEqual(library.get('uuid', 3), null, 'uuid/3 remains portable Prolog');
         for (const [name, arity] of [['not_member', 2], ['head', 2], ['rest', 2], ['min', 3], ['max', 3]]) {
           assertEqual(library.get(name, arity), null, `${name}/${arity} removed from library`);
         }
@@ -1037,24 +1047,30 @@ 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', 'library-source.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');
+        assertEqual(Boolean(program.findGroup('random', 3)), true, 'random/3 is autoloaded as a clause group');
       },
     },
     {
       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() });
         const goal = parseGoalText('portable_check(A, B, C)');
         const answers = [...solver.solve([goal], new Env(), 0)].map((env) => termToString(goal, env, true));
         assertEqual(answers.join('\n'), "portable_check(hello, baNANA, [x, y])", 'ISO-only portable execution');
-        assertEqual(program.findGroup('uuid', 1), null, 'uuid/1 remains outside portable file');
-        assertEqual(program.findGroup('local_time', 1), null, 'local_time/1 remains outside portable file');
+        assertEqual(Boolean(program.findGroup('uuid', 3)), true, 'uuid/3 is implemented in the portable file');
+        assertEqual(program.findGroup('uuid', 1), null, 'obsolete uuid/1 is absent');
+        assertEqual(program.findGroup('local_time', 1), null, 'local_time/1 is absent from the library');
       },
     },
     {
@@ -1699,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 './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: 48 public predicates written as ordinary
-Prolog clauses against that ISO profile. `src/library-source.js` loads the same
-file in Node and the browser, while `src/library.js` owns autoload integration
-and the two unavoidable public host predicates, `uuid/1` and `local_time/1`.
+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.
 
@@ -5253,17 +5254,18 @@ so side effects occur in Prolog execution order.
 ### The EyeProlog library
 
 EyeProlog exposes **50 library predicate indicators** in addition to the 115
-indicators in its isolated ISO profile. Of those 50, **48 are ordinary Prolog
-clauses** in `src/eyeprolog-library.pl`; only **`uuid/1` and `local_time/1` are
-native host predicates** because ISO Prolog provides neither entropy nor a wall
-clock. The resulting normal EyeProlog language surface is therefore **165
-public predicate indicators**. Internally, the runtime registry has 117
-definitions: 115 ISO predicates and the 2 public host predicates.
-
-The portable file is autoloaded once into every `Program` used with the
-EyeProlog registry. `src/library-source.js` loads it from the package in Node or
-through `fetch()` in the browser; `src/library.js` performs the autoload and
-registers the two host predicates.
+indicators in its isolated ISO profile. **All 50 are ordinary Prolog clauses**
+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 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
@@ -5278,28 +5280,29 @@ 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` |
+| `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/1`, `local_time/1`, `difference/3` |
+| `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` |
 
 <!-- eyeprolog-library-catalog:end -->
 
-`uuid/1` creates one fresh version 4 UUID atom. It is deterministic in
-the Prolog sense: each call has exactly one solution, although the generated atom
-is intentionally different between calls. The implementation uses the Web Crypto API where available and remains
-portable across Node and the browser playground.
+`uuid(+Seed0,-UUID,-Seed)` creates a version 4 UUID atom using `random/3`.
+Passing the returned seed to the next call produces the next UUID; restarting
+with the same integer seed reproduces the same sequence exactly. This explicit
+state replaces hidden host entropy and behaves identically in Node and the
+browser playground.
 
 On the command line, the EyeProlog library is already present:
 
@@ -5335,13 +5338,14 @@ the corresponding predicate.
 | --- | --- |
 | `tan/2`, `asin/2`, `acos/2`, `atan2/3` | Floating-point functions not supplied as evaluable functions by ISO/IEC 13211-1. |
 | `lt(+A,+B)`, `le(+A,+B)`, `gt(+A,+B)`, `ge(+A,+B)` | Compare integers exactly, finite numeric text numerically, `PnYnMnD` duration text component-wise, and other lexical values by string order. These differ from ISO arithmetic comparison and standard term order. |
-| `local_time(-Date)` | The one host relation in this group. Produces the host-local calendar date as atom `'YYYY-MM-DD'`. Tests and reproducible hosts may set `EYEPROLOG_LOCAL_TIME`. |
+| `random(+Seed0,-Value,-Seed)` | Portable Park-Miller generator with explicit state. `Value` is in `[0,1)`; pass the returned integer `Seed` to the next call. The same initial integer seed always reproduces the same sequence. |
 | `difference(+End,+Start,-Duration)` | Portable Prolog. Computes a nonnegative calendar difference between ISO date atoms/character lists and returns atom `'PnYnMnD'`. Invalid dates or an end before the start fail. |
 
 ```eyeprolog
 answer(square, S) :- (S is 12 * 12).
 answer(day_count, N) :- between(3, 5, N).
 answer(age, D) :- difference('2026-07-28', '2020-05-20', D).
+answer(random_pair, [A,B]) :- random(42, A, S), random(S, B, _).
 eyeprolog --goal 'answer(Kind, Value)' program.pl
 ```
 
@@ -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) |
@@ -5778,7 +5783,7 @@ studies.
 | [Socket Age](https://github.com/eyereasoner/eyeprolog/blob/main/examples/socket-age.pl) | Socket and plug declarations for an age-reasoning module with registry, policy, and clock providers. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/socket-age.pl) · [proof](https://github.com/eyereasoner/eyeprolog/blob/main/examples/proof/socket-age.pl) |
 | [Socket Family](https://github.com/eyereasoner/eyeprolog/blob/main/examples/socket-family.pl) | Socket and plug declarations for a family-reasoning module that expects a `parent/2` provider. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/socket-family.pl) · [proof](https://github.com/eyereasoner/eyeprolog/blob/main/examples/proof/socket-family.pl) |
 | [Socrates](https://github.com/eyereasoner/eyeprolog/blob/main/examples/socrates.pl) | A fact and one rule turn the classical syllogism into a ground derivation. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/socrates.pl) · [proof](https://github.com/eyereasoner/eyeprolog/blob/main/examples/proof/socrates.pl) |
-| [UUID](https://github.com/eyereasoner/eyeprolog/blob/main/examples/uuid.pl) | `uuid/1` creates one version 4 UUID atom; the example validates its shape while keeping the checked answer stable. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/uuid.pl) |
+| [UUID](https://github.com/eyereasoner/eyeprolog/blob/main/examples/uuid.pl) | `uuid/3` reproducibly creates one version 4 UUID atom from explicit random state; the example validates its canonical shape. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/uuid.pl) |
 | [Witch](https://github.com/eyereasoner/eyeprolog/blob/main/examples/witch.pl) | Burn the witch, adapted from Eyeling's examples/witch.n3. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/witch.pl) · [proof](https://github.com/eyereasoner/eyeprolog/blob/main/examples/proof/witch.pl) |
 
 Suggested path: Socrates → Age → Ancestor → Derived rule → Reusable built-ins.
@@ -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) |

package/src/library-source.js

@@ -1,18 +0,0 @@
-// Load the portable EyeProlog Prolog-library source from the package assets.
-// eyeprolog-library.pl is the source of truth for all 48 portable public
-// library predicates.
-import { fs, isNode } from './platform.js';
-
-const portableLibraryUrl = new URL('./eyeprolog-library.pl', import.meta.url);
-
-async function loadSource(url, label) {
-  if (isNode) return fs.readFileSync(url, 'utf8');
-  const response = await fetch(url);
-  if (!response.ok) throw new Error(`could not load ${label}: ${response.status}`);
-  return response.text();
-}
-
-export const eyePrologPortableLibrarySource = await loadSource(
-  portableLibraryUrl,
-  'EyeProlog portable library',
-);

package/src/library.js

@@ -1,171 +0,0 @@
-// EyeProlog library integration.
-//
-// 48 of the 50 public library predicates are implemented in plain Prolog in
-// eyeprolog-library.pl and autoloaded into every Solver that uses the EyeProlog
-// registry.  Only uuid/1 and local_time/1 remain native because ISO Prolog has
-// no standard entropy or wall-clock primitive.
-import {
-  atom,
-  unify,
-} from './term.js';
-import {
-  BuiltinRegistry,
-  isoBuiltins,
-} from './iso.js';
-import { parseClauses } from './parser.js';
-import { eyePrologPortableLibrarySource } from './library-source.js';
-
-export const eyePrologNativeLibraryIndicators = Object.freeze([
-  'uuid/1',
-  'local_time/1',
-]);
-
-export const eyePrologPortableLibraryIndicators = Object.freeze([
-  'difference/3',
-  'call/3',
-  'maplist/3',
-  'tan/2',
-  'asin/2',
-  'acos/2',
-  'atan2/3',
-  'lt/2',
-  'gt/2',
-  'le/2',
-  'ge/2',
-  'between/3',
-  'smallest_divisor_from/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',
-  'sort/2',
-  'countall/2',
-  'sumall/3',
-  'aggregate_min/5',
-  'aggregate_max/5',
-]);
-
-export const eyePrologLibraryIndicators = Object.freeze([
-  ...eyePrologNativeLibraryIndicators,
-  ...eyePrologPortableLibraryIndicators,
-]);
-
-const portableIndicatorSet = new Set(eyePrologPortableLibraryIndicators);
-const autoloadedPrograms = new WeakSet();
-const portableClauseTemplates = parseClauses(eyePrologPortableLibrarySource, {
-  filename: 'src/eyeprolog-library.pl',
-  sourceMetadata: true,
-});
-
-
-export function ensureEyePrologLibrary(program) {
-  if (autoloadedPrograms.has(program)) return program;
-
-  // User clauses already present in the Program stay first in clause order;
-  // the autoloaded library clauses are appended as defaults. This preserves
-  // useful source specializations such as length(numbers,N) while still making
-  // the relational length(List,N) library clauses available inside them.
-  let added = 0;
-  for (const template of portableClauseTemplates) {
-    // Clause terms are immutable; clone only the mutable indexing shell so the
-    // cached parse can be safely shared across independent Program instances.
-    const clause = {
-      ...template,
-      body: template.body.slice(),
-      index: program.clauses.length,
-      eyePrologLibraryPortable: true,
-    };
-    program.clauses.push(clause);
-    program.indexClause(clause);
-    added++;
-  }
-  if (added > 0) program.markRecursivePredicates();
-  autoloadedPrograms.add(program);
-  return program;
-}
-
-export function createEyePrologRegistry() {
-  const registry = new BuiltinRegistry();
-  registry.eyePrologLibrary = true;
-
-  registry.add('uuid', 1, uuidBuiltin, {
-    deterministic: true,
-    eyePrologLibrary: true,
-  });
-  registry.add('local_time', 1, localTimeBuiltin, {
-    deterministic: true,
-    eyePrologLibrary: true,
-  });
-  // ISO definitions take precedence where names overlap and remain identifiable
-  // as ISO rather than EyeProlog-library predicates.
-  isoBuiltins.register(registry);
-  return registry;
-}
-
-let eyePrologRegistry = null;
-
-export function getEyePrologRegistry() {
-  if (eyePrologRegistry == null) eyePrologRegistry = createEyePrologRegistry();
-  return eyePrologRegistry;
-}
-
-function* uuidBuiltin({ goal, env }) {
-  const next = env.clone();
-  if (unify(goal.args[0], atom(randomUuidV4()), next)) yield next;
-}
-
-function* localTimeBuiltin({ goal, env }) {
-  const next = env.clone();
-  if (unify(goal.args[0], atom(localDateText()), next)) yield next;
-}
-
-function randomUuidV4() {
-  const cryptoApi = globalThis.crypto;
-  if (typeof cryptoApi?.randomUUID === 'function') return cryptoApi.randomUUID();
-  const bytes = new Uint8Array(16);
-  if (typeof cryptoApi?.getRandomValues === 'function') {
-    cryptoApi.getRandomValues(bytes);
-  } else {
-    for (let index = 0; index < bytes.length; index++) bytes[index] = Math.floor(Math.random() * 256);
-  }
-  bytes[6] = (bytes[6] & 0x0f) | 0x40;
-  bytes[8] = (bytes[8] & 0x3f) | 0x80;
-  const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, '0'));
-  return `${hex.slice(0, 4).join('')}-${hex.slice(4, 6).join('')}-${hex.slice(6, 8).join('')}-${hex.slice(8, 10).join('')}-${hex.slice(10).join('')}`;
-}
-
-function localDateText() {
-  const fixed = typeof process !== 'undefined' ? process.env?.EYEPROLOG_LOCAL_TIME : null;
-  if (fixed) return fixed;
-  const now = new Date();
-  const yyyy = now.getFullYear();
-  const mm = String(now.getMonth() + 1).padStart(2, '0');
-  const dd = String(now.getDate()).padStart(2, '0');
-  return `${yyyy}-${mm}-${dd}`;
-}