eyeprolog 1.3.78 → 1.3.80

package/src/lib/when.pl

@@ -0,0 +1,103 @@
+/**
+Provides the predicate `when/2`.
+*/
+
+:- module(when, [when/2]).
+
+:- use_module(library(atts)).
+:- use_module(library(dcgs)).
+:- use_module(library(lists)).
+:- use_module(library(format)).
+:- use_module(library(debug)).
+
+:- attribute when_list/1.
+
+:- meta_predicate(when(+, 0)).
+
+%% when(Condition, Goal).
+%
+% Executes Goal when Condition becomes true.
+% Condition may consist of `ground(T)`, `nonvar(T)`, `C1,C2`, `C1;C2`.
+when(Condition, Goal) :-
+    (   when_condition(Condition) ->
+        (   Condition ->
+            Goal
+        ;   term_variables(Condition, Vars),
+            maplist(when_add_goal(Goal, Condition), Vars)
+        )
+    ;   throw(error(domain_error(when_condition, Condition),_))
+    ).
+
+when_add_goal(Goal, Condition, Var) :-
+    (   get_atts(Var, when_list(Whens0)) ->
+        Whens = [when(Condition, Goal) | Whens0],
+        put_atts(Var, when_list(Whens))
+    ;   put_atts(Var, when_list([when(Condition, Goal)]))
+    ).
+
+when_condition(Cond) :-
+    % Should this be delayed?
+    var(Cond), !, throw(error(instantiation_error,when_condition/1)).
+when_condition(ground(_)).
+when_condition(nonvar(_)).
+when_condition((A, B)) :-
+    when_condition(A),
+    when_condition(B).
+when_condition((A ; B)) :-
+    when_condition(A),
+    when_condition(B).
+
+remove_goal([], _, []).
+remove_goal([G0|G0s], Goal, Goals) :-
+    (   G0 == Goal ->
+        remove_goal(G0s, Goal, Goals)
+    ;   Goals = [G0|Goals1],
+        remove_goal(G0s, Goal, Goals1)
+    ).
+
+vars_remove_goal(Vars, Goal) :-
+    maplist(when_remove_goal(Goal), Vars).
+
+when_remove_goal(Goal, Var) :-
+    (   get_atts(Var, when_list(Whens0)) ->
+        remove_goal(Whens0, Goal, Whens),
+        (   Whens = [] ->
+            put_atts(Var, -when_list(_))
+        ;   put_atts(Var, when_list(Whens))
+        )
+    ;   true
+    ).
+
+reinforce_goal(Goal0, Goal) :-
+    Goal = (
+        term_variables(Goal0, Vars),
+        when:vars_remove_goal(Vars, Goal0),
+        Goal0
+    ).
+
+verify_attributes(Var, Value, Goals) :-
+    (   get_atts(Var, when_list(Whens)) ->
+        (   var(Value) ->
+            (   get_atts(Value, when_list(WhensValue)) ->
+                append(Whens, WhensValue, WhensNew),
+                put_atts(Value, when_list(WhensNew))
+            ;   put_atts(Value, when_list(Whens))
+            ),
+            Goals = []
+        ;   maplist(reinforce_goal, Whens, Goals)
+        )
+    ;   Goals = []
+    ).
+
+gather_when_goals([], _) --> [].
+gather_when_goals([When|Whens], Var) -->
+    ( { term_variables(When, [V0|_]), Var == V0 } ->
+        [when:When]
+    ;   []
+    ),
+    gather_when_goals(Whens, Var).
+
+attribute_goals(Var) -->
+    { get_atts(Var, when_list(Whens)) },
+    gather_when_goals(Whens, Var),
+    { put_atts(Var, -when_list(_)) }.

package/src/parser.js

@@ -381,6 +381,12 @@ class Parser {
       // Scryer library(atts) exports this declaration operator. EyeProlog
       // handles the directive directly instead of relying on term expansion.
       this.defineOperator(1199, 'fx', 'attribute');
+    } else if (designation.args[0].name === 'tabling') {
+      this.defineOperator(1150, 'fx', 'table');
+    } else if (designation.args[0].name === 'debug') {
+      this.defineOperator(900, 'fx', '$');
+      this.defineOperator(900, 'fx', '$-');
+      this.defineOperator(950, 'fy', '*');
     }
   }
   operatorTokenName(token = this.token) {
@@ -1041,7 +1047,7 @@ class Parser {
           (['char_conversion', 'set_prolog_flag'].includes(directive.name) && directive.arity === 2)
         );
         const extensionDirective = directive.type === 'compound' && (
-          (['use_module', 'meta_predicate', 'attribute'].includes(directive.name) && directive.arity === 1) ||
+          (['use_module', 'meta_predicate', 'attribute', 'table'].includes(directive.name) && directive.arity === 1) ||
           (['module', 'use_module'].includes(directive.name) && directive.arity === 2)
         );
         if (this.strictIso && extensionDirective) {

package/src/playground-worker.js

@@ -1,7 +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 { createEyePrologRegistry, run } from './index.js?playground=20260811c';
+import { createEyePrologRegistry, run } from './index.js?playground=20260825a';
 
 const registry = createEyePrologRegistry();
 

package/src/program.js

@@ -1412,8 +1412,9 @@ function annotateGoalModule(term, module) {
   if (!term || (term.type !== ATOM && term.type !== COMPOUND)) return term;
   term.module = module;
   const callableArguments = (term.name === ',' || term.name === ';' || term.name === '->') ? term.args
-    : (['call', 'once', '\\+', 'not', 'catch', 'forall', 'findall', 'bagof', 'setof',
-      'countall', 'sumall', 'aggregate_min', 'aggregate_max', 'maplist'].includes(term.name)
+    : (['call', 'once', '\\+', 'not', 'catch', 'call_cleanup', 'setup_call_cleanup',
+      'forall', 'findall', 'bagof', 'setof', 'countall', 'sumall',
+      'aggregate_min', 'aggregate_max', 'maplist', 'phrase'].includes(term.name)
       ? term.args
       : []);
   for (const arg of callableArguments) annotateGoalModule(arg, module);

package/src/scryer-compat.js

@@ -4,8 +4,9 @@
 // backtrackable blackboard lives in Env so ordinary Prolog choice points undo
 // writes automatically.
 
-import { ATOM, NUMBER, STRING, deref, unify } from './term.js';
+import { ATOM, COMPOUND, NUMBER, STRING, VAR, atom, compound, deref, listFromItems, unify } from './term.js';
 import { PrologError } from './errors.js';
+import { formatTermForWrite } from './write.js';
 
 function blackboardKey(term, env) {
   const value = deref(term, env);
@@ -31,9 +32,188 @@ function* bbPutBuiltin({ goal, env }) {
   yield next;
 }
 
+function* bbGlobalGetBuiltin({ solver, goal, env }) {
+  const key = blackboardKey(goal.args[0], env);
+  const stored = solver.nonBacktrackableBlackboard.get(key);
+  if (stored === undefined) return;
+  const next = env.clone();
+  if (unify(goal.args[1], stored, next)) yield next;
+}
+
+function* bbGlobalPutBuiltin({ solver, goal, env }) {
+  const key = blackboardKey(goal.args[0], env);
+  solver.nonBacktrackableBlackboard.set(key, deref(goal.args[1], env));
+  yield env;
+}
+
+const charTypeNames = new Set([
+  'alnum', 'alpha', 'alphabetic', 'alphanumeric', 'ascii', 'ascii_graphic',
+  'ascii_punctuation', 'binary_digit', 'control', 'decimal_digit', 'exponent',
+  'graphic', 'graphic_token', 'hexadecimal_digit', 'layout', 'lower', 'meta',
+  'numeric', 'octal_digit', 'octet', 'prolog', 'sign', 'solo',
+  'symbolic_control', 'symbolic_hexadecimal', 'upper', 'whitespace',
+]);
+
+function charTypeCandidates(ch) {
+  const code = ch.codePointAt(0);
+  const letter = /\p{L}/u.test(ch);
+  const decimal = /\p{Nd}/u.test(ch);
+  const numeric = /\p{N}/u.test(ch);
+  const whitespace = /\s/u.test(ch);
+  const control = /\p{Cc}/u.test(ch);
+  const lower = /\p{Ll}/u.test(ch);
+  const upper = /\p{Lu}/u.test(ch);
+  const asciiGraphic = code >= 0x21 && code <= 0x7e;
+  const out = [];
+  const add = (name, yes) => { if (yes) out.push(atom(name)); };
+  add('alnum', letter || decimal);
+  add('alpha', letter);
+  add('alphabetic', letter);
+  add('alphanumeric', letter || decimal);
+  add('ascii', code <= 0x7f);
+  add('ascii_graphic', asciiGraphic);
+  add('ascii_punctuation', asciiGraphic && !letter && !decimal);
+  add('binary_digit', ch === '0' || ch === '1');
+  add('control', control);
+  add('decimal_digit', decimal);
+  add('exponent', ch === 'e' || ch === 'E');
+  add('graphic', !whitespace && !control);
+  add('graphic_token', '#$&*+-./:<=>?@\\^~'.includes(ch));
+  add('hexadecimal_digit', /^[0-9A-Fa-f]$/.test(ch));
+  add('layout', whitespace);
+  add('lower', lower);
+  add('meta', "\\'\"`".includes(ch));
+  add('numeric', numeric);
+  add('octal_digit', /^[0-7]$/.test(ch));
+  add('octet', code <= 0xff);
+  add('prolog', true);
+  add('sign', ch === '+' || ch === '-');
+  add('solo', '!,;[]{}()|'.includes(ch));
+  add('symbolic_control', '#$&*+-./:<=>?@\\^~'.includes(ch));
+  add('symbolic_hexadecimal', /^[A-Fa-f]$/.test(ch));
+  add('upper', upper);
+  add('whitespace', whitespace);
+  out.push(compound('lower', [listFromItems([...ch.toLowerCase()].map(atom))]));
+  out.push(compound('upper', [listFromItems([...ch.toUpperCase()].map(atom))]));
+  return out;
+}
+
+function validCharType(term) {
+  return (term.type === ATOM && charTypeNames.has(term.name)) ||
+    (term.type === COMPOUND && ['lower', 'upper'].includes(term.name) && term.arity === 1);
+}
+
+function* charTypeBuiltin({ goal, env }) {
+  const char = deref(goal.args[0], env);
+  const type = deref(goal.args[1], env);
+  if (char.type === VAR && type.type === VAR) throw new PrologError('instantiation_error');
+  if (char.type !== VAR && (char.type !== ATOM || [...char.name].length !== 1)) {
+    throw new PrologError('type_error(character)', char);
+  }
+  if (type.type !== VAR && !validCharType(type)) throw new PrologError('domain_error(char_type)', type);
+
+  const chars = char.type === VAR
+    ? (function* unicodeScalars() {
+        for (let code = 0; code <= 0x10ffff; code++) {
+          if (code >= 0xd800 && code <= 0xdfff) continue;
+          yield String.fromCodePoint(code);
+        }
+      })()
+    : [char.name];
+  for (const ch of chars) {
+    for (const candidate of charTypeCandidates(ch)) {
+      const next = env.clone();
+      if (unify(goal.args[0], atom(ch), next) && unify(goal.args[1], candidate, next)) yield next;
+    }
+  }
+}
+
+const shortMonths = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
+  'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+const longMonths = ['January', 'February', 'March', 'April', 'May', 'June',
+  'July', 'August', 'September', 'October', 'November', 'December'];
+const shortWeekdays = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+const longWeekdays = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+
+function chars(value) {
+  return listFromItems([...String(value)].map(atom));
+}
+
+function* currentTimeBuiltin({ goal, env }) {
+  const now = new Date();
+  const pad = (value, width = 2) => String(value).padStart(width, '0');
+  const dayOfYear = Math.floor((
+    Date.UTC(now.getFullYear(), now.getMonth(), now.getDate()) -
+    Date.UTC(now.getFullYear(), 0, 1)
+  ) / 86400000) + 1;
+  const entries = [
+    ['Y', String(now.getFullYear())],
+    ['m', pad(now.getMonth() + 1)],
+    ['d', pad(now.getDate())],
+    ['H', pad(now.getHours())],
+    ['M', pad(now.getMinutes())],
+    ['S', pad(now.getSeconds())],
+    ['y', pad(now.getFullYear() % 100)],
+    ['b', shortMonths[now.getMonth()]],
+    ['B', longMonths[now.getMonth()]],
+    ['a', shortWeekdays[now.getDay()]],
+    ['A', longWeekdays[now.getDay()]],
+    ['w', String(now.getDay())],
+    ['u', String(now.getDay() === 0 ? 7 : now.getDay())],
+    ['j', pad(dayOfYear, 3)],
+  ].map(([key, value]) => compound('=', [atom(key), chars(value)]));
+  const next = env.clone();
+  if (unify(goal.args[0], listFromItems(entries), next)) yield next;
+}
+
+function* abolishAllTablesBuiltin({ solver, env }) {
+  solver.memo.clear();
+  solver.subsumptiveMemo.clear();
+  solver.wfsModels.clear();
+  solver.datalogModels.clear();
+  solver.tableCoordinator = null;
+  solver.groundChainSuccess.clear();
+  solver.compactChainSuccess.clear();
+  for (const scope of solver.innerTableScopes.values()) {
+    scope.memo.clear();
+    scope.subsumptiveMemo.clear();
+  }
+  yield env;
+}
+
+function* termCharsBuiltin({ solver, goal, env }) {
+  const mode = deref(goal.args[0], env);
+  if (mode.type !== ATOM || !['a', 'd', 'q', 'w'].includes(mode.name)) {
+    throw new PrologError('domain_error(format_control)', mode);
+  }
+  const value = deref(goal.args[1], env);
+  if (mode.name === 'd' && value.type !== NUMBER) throw new PrologError('type_error(integer)', value);
+  if (mode.name === 'a' && ![ATOM, NUMBER, STRING].includes(value.type)) {
+    throw new PrologError('type_error(atomic)', value);
+  }
+  const text = formatTermForWrite(goal.args[1], env, {
+    quoted: mode.name === 'q',
+    numbervars: true,
+    compact: true,
+    minimalOperatorSpacing: true,
+    operatorAtomsAsArgs: true,
+    generateVariableNames: true,
+    variableNameState: solver.writeVariableState,
+    operators: solver.program.operators.values(),
+  });
+  const next = env.clone();
+  if (unify(goal.args[2], chars(text), next)) yield next;
+}
+
 export const scryerCompatibilityBuiltins = {
   register(registry) {
     registry.add('eyeprolog__bb_get', 2, bbGetBuiltin, { eyePrologLibrary: true });
     registry.add('eyeprolog__bb_b_put', 2, bbPutBuiltin, { deterministic: true, eyePrologLibrary: true });
+    registry.add('eyeprolog__bb_global_get', 2, bbGlobalGetBuiltin, { eyePrologLibrary: true });
+    registry.add('eyeprolog__bb_global_put', 2, bbGlobalPutBuiltin, { deterministic: true, eyePrologLibrary: true });
+    registry.add('eyeprolog__char_type', 2, charTypeBuiltin, { eyePrologLibrary: true });
+    registry.add('eyeprolog__current_time', 1, currentTimeBuiltin, { deterministic: true, eyePrologLibrary: true });
+    registry.add('eyeprolog__abolish_all_tables', 0, abolishAllTablesBuiltin, { deterministic: true, eyePrologLibrary: true });
+    registry.add('eyeprolog__term_chars', 3, termCharsBuiltin, { deterministic: true, eyePrologLibrary: true });
   },
 };

package/src/solver.js

@@ -185,6 +185,9 @@ export class Solver {
     // distinct meta-call inputs must not turn completed table variants into
     // process-lifetime roots.
     this.innerTableScopes = options.innerTableScopes ?? new Map();
+    // Non-backtrackable library state (for example gensym/2 and CLP(B) node
+    // identifiers) is shared by nested solvers for the lifetime of this run.
+    this.nonBacktrackableBlackboard = options.nonBacktrackableBlackboard ?? new Map();
     this.stats = {
       completed_goal_lists: 0,
       solve_goals_calls: 0,
@@ -216,6 +219,7 @@ export class Solver {
       charConversions: this.charConversions,
       io: this.io,
       innerTableScopes: this.innerTableScopes,
+      nonBacktrackableBlackboard: this.nonBacktrackableBlackboard,
       inferenceObservation: this.inferenceObservation,
       writeVariableState: this.writeVariableState,
       skipListTailTabling: options.skipListTailTabling ?? this.skipListTailTabling,

package/src/standard-library.js

@@ -16,30 +16,41 @@ const moduleFiles = Object.freeze({
   assoc: 'assoc.pl',
   atts: 'atts.pl',
   between: 'between.pl',
+  charsio: 'charsio.pl',
+  clpb: 'clpb.pl',
   clpz: 'clpz.pl',
   comparison: 'comparison.pl',
   dates: 'dates.pl',
   dcgs: 'dcgs.pl',
   debug: 'debug.pl',
+  dif: 'dif.pl',
   error: 'error.pl',
   format: 'format.pl',
   freeze: 'freeze.pl',
+  gensym: 'gensym.pl',
   iso_ext: 'iso_ext.pl',
   lambda: 'lambda.pl',
   lists: 'lists.pl',
+  ordsets: 'ordsets.pl',
   pairs: 'pairs.pl',
+  pio: 'pio.pl',
   primes: 'primes.pl',
   prologue: 'prologue.pl',
   random: 'random.pl',
+  reif: 'reif.pl',
   si: 'si.pl',
   strings: 'strings.pl',
   terms: 'terms.pl',
+  tabling: 'tabling.pl',
+  time: 'time.pl',
+  ugraphs: 'ugraphs.pl',
   uuid: 'uuid.pl',
+  when: 'when.pl',
 });
 
 const cacheKey = isNode
   ? null
-  : (new URL(import.meta.url).searchParams.get('playground') ?? '20260811c');
+  : (new URL(import.meta.url).searchParams.get('playground') ?? '20260825a');
 
 export const standardLibrarySources = new Map(await Promise.all(
   Object.entries(moduleFiles).map(async ([name, filename]) => [name, {
@@ -69,25 +80,70 @@ export const eyePrologNativeLibraryIndicators = Object.freeze([
   'in/2', 'ins/2', 'all_different/1', 'all_distinct/1', 'nvalue/2', 'sum/3',
   'scalar_product/4', 'tuples_in/2', 'labeling/2', 'label/1',
   'indomain/1', 'lex_chain/1', 'serialized/2', 'global_cardinality/2',
-  'global_cardinality/3', 'circuit/1', 'chain/2', 'element/3', 'zcompare/3',
+  'global_cardinality/3', 'circuit/1', 'cumulative/1', 'cumulative/2',
+  'disjoint2/1', 'automaton/3', 'automaton/8', 'chain/2', 'element/3', 'zcompare/3',
   'fd_var/1', 'fd_inf/2', 'fd_sup/2', 'fd_size/2', 'fd_dom/2',
+  'clpz_t/2', '#=/3', '#</3',
 ]);
 export const eyePrologPortableLibraryIndicators = Object.freeze([
   'sumall/3', 'aggregate_min/5', 'aggregate_max/5',
-  'lt/2', 'gt/2', 'le/2', 'ge/2', 'difference/3',
-  'maplist/2', 'maplist/3', 'maplist/4', 'maplist/5',
-  'maplist/6', 'maplist/7', 'maplist/8', 'between/3',
-  'smallest_divisor_from/3', 'random/3', 'matches/3', 'split/3',
-  'replace/4', 'lowercase/2', 'uppercase/2', 'trim/2', 'number_string/2',
-  'atom_string/2', 'term_string/2', 'append/2', 'append/3', 'string_concat/3', 'contains/2',
-  'matches/2', 'join/3', 'substring/4', 'member/2', 'memberchk/2', 'select/3', 'last/2', 'same_length/2',
-  'nth0/3', 'nth0/4', 'nth1/3', 'nth1/4', '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',
-  'succ/2', 'foldl/4', 'foldl/5', 'foldl/6',
-  'forall/2', 'cfor/3', 'findall/4', 'variant/2', '.../2', 'uuid/3',
+  'lsb/2', 'msb/2', 'popcount/2',
+  'empty_assoc/1', 'assoc_to_list/2', 'get_assoc/3', 'put_assoc/4',
+  'assoc_to_keys/2', 'assoc_to_values/2', 'del_assoc/4', 'del_max_assoc/4',
+  'del_min_assoc/4', 'gen_assoc/3', 'get_assoc/5', 'is_assoc/1',
+  'list_to_assoc/2', 'map_assoc/2', 'map_assoc/3', 'max_assoc/3',
+  'min_assoc/3', 'ord_list_to_assoc/2',
+  'between/3', 'gen_int/1', 'gen_nat/1', 'numlist/2', 'numlist/3', 'repeat/1',
+  'char_type/2', 'get_line_to_chars/3', 'get_n_chars/3', 'get_single_char/1',
+  'sat/1', 'taut/2', 'labeling/1', 'sat_count/2', 'random_labeling/2', 'weighted_maximum/3',
+  'lt/2', 'gt/2', 'le/2', 'ge/2',
+  'difference/3',
+  'seq/3', 'seqq/3',
+  'debug/1', 'debug/3', 'nodebug/1', 'bb_get/2', 'bb_put/2', 'bb_b_put/2', 'bb_global_get/2',
+  '*/1', '$/1', '$-/1',
+  'must_be/2', 'can_be/2', 'instantiation_error/0', 'instantiation_error/1',
+  'domain_error/2', 'domain_error/3', 'type_error/2', 'type_error/3',
+  'representation_error/1', 'resource_error/1', 'call_with_error_context/2',
+  'format_/4', 'format/2', 'format/3', 'portray_clause_/3',
+  'portray_clause/1', 'portray_clause/2', 'listing/1',
+  'gensym/2', 'reset_gensym/1',
+  'forall/2', 'succ/2', 'cfor/3', 'findall/4', 'variant/2', '.../2',
   '^/3', '^/4', '^/5', '^/6', '^/7', '^/8', '^/9', '^/10',
   '\\/1', '\\/2', '\\/3', '\\/4', '\\/5', '\\/6', '\\/7', '\\/8',
   '+\\/2', '+\\/3', '+\\/4', '+\\/5', '+\\/6', '+\\/7', '+\\/8', '+\\/9',
+  'member/2', 'memberchk/2', 'select/3', 'append/2', 'append/3', 'last/2', 'same_length/2',
+  'nth0/3', 'nth0/4', 'nth1/3', 'nth1/4', 'set_nth0/4', 'take/3', 'drop/3', 'slice/4', 'reverse/2',
+  'length/2', 'maplist/2', 'maplist/3', 'maplist/4', 'maplist/5',
+  'maplist/6', 'maplist/7', 'maplist/8', 'foldl/4', 'foldl/5', 'foldl/6',
+  'sum_list/2', 'min_list/2', 'max_list/2', 'list_to_set/2',
+  'transpose/2', 'list_max/2', 'list_min/2', 'permutation/2',
+  'is_ordset/1', 'list_to_ord_set/2', 'ord_add_element/3', 'ord_del_element/3',
+  'ord_disjoint/2', 'ord_empty/1', 'ord_intersect/2', 'ord_intersect/3',
+  'ord_intersection/2', 'ord_intersection/3', 'ord_intersection/4',
+  'ord_memberchk/2', 'ord_selectchk/3', 'ord_seteq/2', 'ord_subset/2',
+  'ord_subtract/3', 'ord_symdiff/3', 'ord_union/2', 'ord_union/3', 'ord_union/4',
+  'pairs_keys_values/3', 'pairs_keys/2', 'pairs_values/2',
+  'group_pairs_by_key/2', 'map_list_to_pairs/3',
+  'phrase_from_file/2', 'phrase_from_file/3', 'phrase_to_file/2',
+  'phrase_to_file/3', 'phrase_to_stream/2',
+  'smallest_divisor_from/3',
+  'maybe/0', 'random/3', 'random_integer/3', 'set_random/1',
+  ',/3', ';/3', '=/3', 'cond_t/3', 'dif/3', 'if_/3', 'memberd_t/3',
+  'tfilter/3', 'tmember/2', 'tmember_t/3', 'tpartition/4',
+  'atom_si/1', 'integer_si/1', 'atomic_si/1', 'list_si/1', 'character_si/1',
+  'term_si/1', 'chars_si/1', 'dif_si/2', 'not_si/1', 'when_si/2',
+  'matches/3', 'split/3', 'replace/4', 'lowercase/2', 'uppercase/2', 'trim/2',
+  'number_string/2', 'atom_string/2', 'term_string/2', 'string_concat/3',
+  'contains/2', 'matches/2', 'join/3', 'substring/4',
+  'numbervars/3', 'copy_term_nat/2',
+  'start_tabling/2', 'abolish_all_tables/0',
+  'current_time/1', 'format_time/4',
+  'add_edges/3', 'add_vertices/3', 'complement/2', 'compose/3', 'connect_ugraph/3',
+  'del_edges/3', 'del_vertices/3', 'edges/2', 'neighbors/3', 'neighbours/3',
+  'reachable/3', 'top_sort/2', 'top_sort/3', 'transitive_closure/2',
+  'transpose_ugraph/2', 'ugraph_union/3', 'vertices/2', 'vertices_edges_to_ugraph/3',
+  'uuid/3', 'uuid_string/2', 'uuidv4/1', 'uuidv4_string/1',
+  'when/2',
 ]);
 export const eyePrologLibraryIndicators = Object.freeze([
   ...eyePrologPortableLibraryIndicators,
@@ -147,14 +203,58 @@ export const eyePrologInteropAutoload = Object.freeze({
   'between/3': 'between',
 });
 
-export const eyePrologInteropLibraryIndicators = Object.freeze(
-  Object.keys(eyePrologInteropAutoload),
-);
+const eyePrologSharedLibraryIndicators = [
+  'lsb/2', 'msb/2', 'popcount/2',
+  'empty_assoc/1', 'assoc_to_keys/2', 'assoc_to_list/2', 'assoc_to_values/2',
+  'del_assoc/4', 'del_max_assoc/4', 'del_min_assoc/4', 'gen_assoc/3',
+  'get_assoc/3', 'get_assoc/5', 'is_assoc/1', 'list_to_assoc/2',
+  'map_assoc/2', 'map_assoc/3', 'max_assoc/3', 'min_assoc/3',
+  'ord_list_to_assoc/2', 'put_assoc/4',
+  'char_type/2', 'get_line_to_chars/3', 'get_n_chars/3', 'get_single_char/1',
+  'sat/1', 'taut/2', 'labeling/1', 'sat_count/2', 'random_labeling/2', 'weighted_maximum/3',
+  '#>/2', '#</2', '#>=/2', '#=</2', '#=/2', '#\\=/2', '#\\/1',
+  '#<==>/2', '#==>/2', '#<==/2', '#\\//2', '#\\/2', '#/\\/2',
+  'in/2', 'ins/2', 'all_different/1', 'all_distinct/1', 'nvalue/2', 'sum/3',
+  'scalar_product/4', 'tuples_in/2', 'labeling/2', 'label/1', 'indomain/1',
+  'lex_chain/1', 'serialized/2', 'global_cardinality/2', 'global_cardinality/3',
+  'circuit/1', 'cumulative/1', 'cumulative/2', 'disjoint2/1', 'automaton/3',
+  'automaton/8', 'chain/2', 'element/3', 'zcompare/3', 'fd_var/1', 'fd_inf/2',
+  'fd_sup/2', 'fd_size/2', 'fd_dom/2', 'clpz_t/2', '#=/3', '#</3',
+  '*/1', '$/1', '$-/1', 'dif/2',
+  'format_/4', 'format/2', 'format/3', 'portray_clause_/3',
+  'portray_clause/1', 'portray_clause/2', 'listing/1',
+  'gensym/2', 'reset_gensym/1',
+  'transpose/2', 'list_max/2', 'list_min/2', 'permutation/2',
+  'is_ordset/1', 'list_to_ord_set/2', 'ord_add_element/3', 'ord_del_element/3',
+  'ord_disjoint/2', 'ord_empty/1', 'ord_intersect/2', 'ord_intersect/3',
+  'ord_intersection/2', 'ord_intersection/3', 'ord_intersection/4',
+  'ord_memberchk/2', 'ord_selectchk/3', 'ord_seteq/2', 'ord_subset/2',
+  'ord_subtract/3', 'ord_symdiff/3', 'ord_union/2', 'ord_union/3', 'ord_union/4',
+  'phrase_from_file/2', 'phrase_from_file/3', 'phrase_to_file/2',
+  'phrase_to_file/3', 'phrase_to_stream/2',
+  'maybe/0', 'random_integer/3', 'set_random/1',
+  ',/3', ';/3', '=/3', 'cond_t/3', 'dif/3', 'if_/3', 'memberd_t/3',
+  'tfilter/3', 'tmember/2', 'tmember_t/3', 'tpartition/4',
+  'start_tabling/2', 'abolish_all_tables/0', 'current_time/1', 'format_time/4',
+  'add_edges/3', 'add_vertices/3', 'complement/2', 'compose/3', 'connect_ugraph/3',
+  'del_edges/3', 'del_vertices/3', 'edges/2', 'neighbors/3', 'neighbours/3',
+  'reachable/3', 'top_sort/2', 'top_sort/3', 'transitive_closure/2',
+  'transpose_ugraph/2', 'ugraph_union/3', 'vertices/2', 'vertices_edges_to_ugraph/3',
+  'uuid_string/2', 'uuidv4/1', 'uuidv4_string/1', 'when/2',
+];
+
+export const eyePrologInteropLibraryIndicators = Object.freeze([
+  ...new Set([...Object.keys(eyePrologInteropAutoload), ...eyePrologSharedLibraryIndicators]),
+]);
 
 // Libraries whose *name* is part of the current interop profile.  A program
 // may freely use_module/1 with these common module names; predicates in those
 // modules outside eyePrologInteropLibraryIndicators are still diagnosed when used.
-export const eyePrologInteropLibraryModules = Object.freeze(['lists', 'iso_ext', 'lambda', 'atts', 'freeze']);
+export const eyePrologInteropLibraryModules = Object.freeze([
+  'arithmetic', 'assoc', 'atts', 'charsio', 'clpb', 'clpz', 'debug', 'dif',
+  'format', 'freeze', 'gensym', 'iso_ext', 'lambda', 'lists', 'ordsets', 'pio',
+  'random', 'reif', 'tabling', 'time', 'ugraphs', 'uuid', 'when',
+]);
 
 function* tabledNegationBuiltin({ solver, goal, env }) {
   yield* solver.solveTabledNegation(goal.args[0], env);