eyeprolog 1.5.12 → 1.5.14

package/README.md

@@ -61,7 +61,7 @@ Normal mode executes top-level `Conclusion :+ Premise` rules through the bundled
 
 Bundled `src/lib/` predicates autoload in files, CLI/API goals, and the REPL; use `--no-autoload` to require explicit imports, and explicitly import libraries that introduce operators before using their syntax. See [*The Art of EyeProlog*](the-art-of-eyeprolog.md) for the full semantics.
 
-All 32 bundled modules that overlap Scryer's current `src/lib/` surface now cover Scryer's exported predicates, while the stricter Trealla/Scryer intersection remains a separate portability profile. Runtime-dependent library primitives follow one ownership rule: `src/lib/<module>.pl` calls private adapters from `src/<module>-host.js`; pure Prolog libraries need no host file. This includes the full Scryer `library(files)` surface, Scryer character-list paths in `library(pio)` with atom-path compatibility, chars/UTF-8/term/Base64 helpers, the completed arithmetic/time/`iso_ext` surfaces, and the full Scryer `library(crypto)`. Filesystem and OS side effects require Node; crypto uses Node's backend where needed, with Web Crypto also used for secure random bytes when available. Non-integral rational conversions remain structural `rdiv(Numerator,Denominator)` terms until rational numbers become processor numeric values.
+All 32 bundled modules that overlap Scryer's current `src/lib/` surface cover Scryer's exported predicates, and all 26 bundled modules with public-module counterparts in Trealla's current `library/` surface cover those Trealla exports as well. The stricter Trealla/Scryer intersection remains a separate portability profile. Runtime-dependent library primitives follow one ownership rule: `src/lib/<module>.pl` calls private adapters from `src/<module>-host.js`; pure Prolog libraries need no host file. This includes the full Scryer `library(files)` surface, Scryer character-list paths in `library(pio)` with atom-path compatibility, chars/UTF-8/term/Base64 helpers, the completed arithmetic/time/`iso_ext` surfaces, and the full Scryer `library(crypto)`. Filesystem and OS side effects require Node; crypto uses Node's backend where needed, with Web Crypto also used for secure random bytes when available. Non-integral rational conversions remain structural `rdiv(Numerator,Denominator)` terms until rational numbers become processor numeric values.
 
 ## Links
 

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.5.12",
+  "version": "1.5.14",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",
@@ -46,7 +46,7 @@
   },
   "scripts": {
     "test": "node test/run-all.mjs",
-    "generate": "node tools/generate-library-autoload-index.mjs && node tools/extract-book-examples.mjs",
+    "generate": "node tools/generate-library-autoload-index.mjs && node tools/generate-predicate-reference.mjs && node tools/extract-book-examples.mjs",
     "generate:autoload": "node tools/generate-library-autoload-index.mjs",
     "test:eyeprolog": "node test/run-all.mjs",
     "test:conformance": "node test/run-conformance.mjs",
@@ -69,6 +69,7 @@
     "test:architecture": "node test/run-architecture.mjs",
     "benchmark": "node test/benchmark.mjs",
     "benchmark:baseline": "node test/benchmark.mjs --save .benchmarks/baseline.json",
-    "test:benchmark": "node test/run-benchmark-tests.mjs"
+    "test:benchmark": "node test/run-benchmark-tests.mjs",
+    "generate:reference": "node tools/generate-predicate-reference.mjs"
   }
 }

package/src/lib/aggregate.pl

@@ -1,8 +1,17 @@
 /** Portable solution aggregation relations. */
 
-:- module(aggregate, [sumall/3, aggregate_min/5, aggregate_max/5]).
+/* Trealla-compatible aggregate_all/3 and aggregate/3 behavior is adapted
+   from Trealla Prolog library/aggregate.pl (MIT),
+   Copyright (c) 2020 Andrew George Davison. */
+
+:- module(aggregate, [
+    sumall/3, aggregate_min/5, aggregate_max/5,
+    aggregate_all/3, aggregate/3
+]).
 
 :- meta_predicate(sumall('?', 0, '?')).
+:- meta_predicate(aggregate_all('?', 0, '?')).
+:- meta_predicate(aggregate('?', 0, '?')).
 :- meta_predicate(aggregate_min('?', '?', 0, '?', '?')).
 :- meta_predicate(aggregate_max('?', '?', 0, '?', '?')).
 
@@ -31,3 +40,71 @@ aggregate__reverse([X|Xs], Acc, Out) :- aggregate__reverse(Xs, [X|Acc], Out).
 aggregate__last_pair([Pair], Pair).
 aggregate__last_pair([_|Pairs], Pair) :- aggregate__last_pair(Pairs, Pair).
 
+
+% Trealla-compatible aggregate templates.  These are source-level relations;
+% EyeProlog keeps its older sumall/3 and aggregate_min/max helpers alongside
+% them for backward compatibility.
+aggregate_all(Aggregate, Goal, Result) :-
+    aggregate__init(Aggregate, Template, Initial),
+    findall(Template, Goal, Values),
+    aggregate__compute(Values, Aggregate, Initial, Result).
+
+aggregate(Aggregate, Goal, Result) :-
+    aggregate__init(Aggregate, Template, Initial),
+    bagof(Template, Goal, Values),
+    aggregate__compute(Values, Aggregate, Initial, Result).
+
+aggregate__compute([], Aggregate, Initial, Result) :-
+    aggregate__finish(Aggregate, Initial, Result).
+aggregate__compute([Value|Values], Aggregate, Acc0, Result) :-
+    aggregate__next(Aggregate, Acc0, Value, Acc),
+    aggregate__compute(Values, Aggregate, Acc, Result).
+
+aggregate__init(Aggregate, _, _) :- var(Aggregate), !,
+    throw(error(instantiation_error, aggregate/3)).
+aggregate__init(count, '', 0) :- !.
+aggregate__init(sum(X), X, 0) :- !.
+aggregate__init(mul(X), X, 1) :- !.
+aggregate__init(min(X), X, sup) :- !.
+aggregate__init(max(X), X, inf) :- !.
+aggregate__init(bag(X), X, []) :- !.
+aggregate__init(set(X), X, []) :- !.
+aggregate__init((F,G), (X,Y), (A,B)) :- !,
+    aggregate__init(F, X, A),
+    aggregate__init(G, Y, B).
+aggregate__init(Aggregate, _, _) :-
+    throw(error(type_error(aggregate, Aggregate), aggregate/3)).
+
+aggregate__next(count, A, '', C) :- C is A + 1.
+aggregate__next(sum(_), A, B, C) :- C is A + B.
+aggregate__next(mul(_), A, B, C) :- C is A * B.
+aggregate__next(min(_), A, B, C) :- aggregate__min(A, B, C).
+aggregate__next(max(_), A, B, C) :- aggregate__max(A, B, C).
+aggregate__next(bag(_), A, B, [B|A]).
+aggregate__next(set(_), A, B, [B|A]).
+aggregate__next((F,G), (A,B), (X,Y), (C,D)) :-
+    aggregate__next(F, A, X, C),
+    aggregate__next(G, B, Y, D).
+
+aggregate__finish(count, A, A).
+aggregate__finish(sum(_), A, A).
+aggregate__finish(mul(_), A, A).
+aggregate__finish(min(_), A, A).
+aggregate__finish(max(_), A, A).
+aggregate__finish(bag(_), A, B) :- aggregate__reverse(A, [], B).
+aggregate__finish(set(_), A, B) :- aggregate__reverse(A, [], R), sort(R, B).
+aggregate__finish((F,G), (X,Y), (A,B)) :-
+    aggregate__finish(F, X, A),
+    aggregate__finish(G, Y, B).
+
+aggregate__min(sup, X, X) :- !.
+aggregate__min(X, sup, X) :- !.
+aggregate__min(inf, _, inf) :- !.
+aggregate__min(_, inf, inf) :- !.
+aggregate__min(X, Y, R) :- R is min(X, Y).
+
+aggregate__max(inf, X, X) :- !.
+aggregate__max(X, inf, X) :- !.
+aggregate__max(sup, _, sup) :- !.
+aggregate__max(_, sup, sup) :- !.
+aggregate__max(X, Y, R) :- R is max(X, Y).

package/src/lib/error.pl

@@ -11,6 +11,7 @@
     type_error/3,
     representation_error/1,
     resource_error/1,
+    resource_error/2,
     call_with_error_context/2
 ]).
 
@@ -118,6 +119,7 @@ type_error(Type, Term) :- throw(error(type_error(Type, Term), [])).
 type_error(Type, Term, Context) :- throw(error(type_error(Type, Term), Context)).
 representation_error(Flag) :- throw(error(representation_error(Flag), [])).
 resource_error(Resource) :- throw(error(resource_error(Resource), [])).
+resource_error(Resource, Context) :- throw(error(resource_error(Resource), Context)).
 
 call_with_error_context(Goal, Pair) :-
     catch(Goal, error(Error, Context), throw(error(Error, [Pair|Context]))).

package/src/lib/freeze.pl

@@ -1,8 +1,9 @@
-/** Attributed-variable implementation of Scryer-compatible freeze/2. */
+/** Attributed-variable freeze/2 plus Trealla-compatible frozen/2 inspection. */
 
-:- module(freeze, [freeze/2]).
+:- module(freeze, [freeze/2, frozen/2]).
 
 :- use_module(library(atts)).
+:- use_module(library(iso_ext), [copy_term/3]).
 :- meta_predicate(freeze(-, 0)).
 :- attribute frozen/1.
 
@@ -27,6 +28,23 @@ freeze(X, Goal) :-
     put_atts(Fresh, frozen(frozen_goal(Goal))),
     Fresh = X.
 
+% Trealla-compatible frozen/2.  copy_term/3 already projects both native and
+% Prolog-defined attributed-variable residual goals.  Re-unifying the fresh
+% structural copy aliases those projected variables back to Term without
+% instantiating them, so Goal describes the suspensions on the original term.
+frozen(Term, Goal) :-
+    copy_term(Term, Copy, Goals),
+    Term = Copy,
+    freeze__goals_conjunction(Goals, Goal).
+
+freeze__goals_conjunction([], true).
+freeze__goals_conjunction([Goal|Goals], Conjunction) :-
+    freeze__goals_conjunction_(Goals, Goal, Conjunction).
+
+freeze__goals_conjunction_([], Goal, Goal).
+freeze__goals_conjunction_([Goal|Goals], Acc, Conjunction) :-
+    freeze__goals_conjunction_(Goals, (Acc, Goal), Conjunction).
+
 frozen_goals(Frozen, Goals) :-
     frozen_goals(Frozen, Goals, []).
 

package/src/lib/lists.pl

@@ -4,6 +4,11 @@
     member/2,
     memberchk/2,
     select/3,
+    selectchk/3,
+    subtract/3,
+    union/3,
+    intersection/3,
+    is_set/1,
     append/2,
     append/3,
     last/2,
@@ -14,6 +19,8 @@
     nth1/4,
     reverse/2,
     length/2,
+    exclude/3,
+    include/3,
     maplist/2,
     maplist/3,
     maplist/4,
@@ -22,6 +29,13 @@
     maplist/7,
     maplist/8,
     maplist/9,
+    tasklist/2,
+    tasklist/3,
+    tasklist/4,
+    tasklist/5,
+    tasklist/6,
+    tasklist/7,
+    tasklist/8,
     foldl/4,
     foldl/5,
     foldl/6,
@@ -50,6 +64,16 @@
 :- meta_predicate(foldl(3, '?', '?', '?')).
 :- meta_predicate(foldl(4, '?', '?', '?', '?')).
 :- meta_predicate(foldl(5, '?', '?', '?', '?', '?')).
+:- meta_predicate(include(1, '?', '?')).
+:- meta_predicate(exclude(1, '?', '?')).
+:- meta_predicate(tasklist(1, '?')).
+:- meta_predicate(tasklist(2, '?', '?')).
+:- meta_predicate(tasklist(3, '?', '?', '?')).
+:- meta_predicate(tasklist(4, '?', '?', '?', '?')).
+:- meta_predicate(tasklist(5, '?', '?', '?', '?', '?')).
+:- meta_predicate(tasklist(6, '?', '?', '?', '?', '?', '?')).
+:- meta_predicate(tasklist(7, '?', '?', '?', '?', '?', '?', '?')).
+
 
 % Common pure-Prolog library predicates for EyeProlog.
 %
@@ -99,6 +123,27 @@ maplist(Closure, [A|As], [B|Bs], [C|Cs], [D|Ds], [E|Es], [F|Fs], [G|Gs], [H|Hs])
     eyeprolog__call8(Closure, A, B, C, D, E, F, G, H),
     maplist(Closure, As, Bs, Cs, Ds, Es, Fs, Gs, Hs).
 
+include(_, [], []).
+include(Predicate, [X|Xs], Included) :-
+    ( call(Predicate, X) -> Included = [X|Rest] ; Included = Rest ),
+    include(Predicate, Xs, Rest).
+
+exclude(_, [], []).
+exclude(Predicate, [X|Xs], Excluded) :-
+    ( call(Predicate, X) -> Excluded = Rest ; Excluded = [X|Rest] ),
+    exclude(Predicate, Xs, Rest).
+
+% Trealla runs tasklist/* items through its task scheduler.  EyeProlog has no
+% task scheduler, so the compatibility surface deliberately uses deterministic
+% sequential maplist semantics while preserving solutions and failures.
+tasklist(Goal, A) :- maplist(Goal, A).
+tasklist(Goal, A, B) :- maplist(Goal, A, B).
+tasklist(Goal, A, B, C) :- maplist(Goal, A, B, C).
+tasklist(Goal, A, B, C, D) :- maplist(Goal, A, B, C, D).
+tasklist(Goal, A, B, C, D, E) :- maplist(Goal, A, B, C, D, E).
+tasklist(Goal, A, B, C, D, E, F) :- maplist(Goal, A, B, C, D, E, F).
+tasklist(Goal, A, B, C, D, E, F, G) :- maplist(Goal, A, B, C, D, E, F, G).
+
 append([], []).
 append([Xs|Xss], Ys) :-
     append(Xs, Rest, Ys),
@@ -115,6 +160,25 @@ memberchk(X, Xs) :- member(X, Xs), !.
 select(X, [X|Xs], Xs).
 select(X, [Y|Ys], [Y|Zs]) :- select(X, Ys, Zs).
 
+selectchk(X, Xs, Rest) :- select(X, Xs, Rest), !.
+
+subtract([], _, []) :- !.
+subtract([X|Xs], Ys, Rest) :- memberchk(X, Ys), !, subtract(Xs, Ys, Rest).
+subtract([X|Xs], Ys, [X|Rest]) :- subtract(Xs, Ys, Rest).
+
+union([], Ys, Ys).
+union([X|Xs], Ys, Union) :- member(X, Ys), !, union(Xs, Ys, Union).
+union([X|Xs], Ys, [X|Union]) :- union(Xs, Ys, Union).
+
+intersection([], _, []).
+intersection([X|Xs], Ys, [X|Intersection]) :- member(X, Ys), !, intersection(Xs, Ys, Intersection).
+intersection([_|Xs], Ys, Intersection) :- intersection(Xs, Ys, Intersection).
+
+is_set(Set) :-
+    sort(Set, Sorted),
+    length(Set, Length),
+    length(Sorted, Length).
+
 last([X], X).
 last([_|Xs], X) :- last(Xs, X).
 

package/src/lib/random.pl

@@ -1,13 +1,13 @@
 /** Reproducible pseudo-random values.
 
-    random/3 is EyeProlog's explicit-state interface.  maybe/0,
+    random/3 is EyeProlog's explicit-state interface.  maybe/0, maybe/1, maybe/2,
     random/1, random_integer/3, and set_random/1 are the mutable-seed library
     interface used for compatibility. random/1 uses EyeProlog's private native
     state step for hot-loop performance; random/3 remains the portable explicit-
     state Park-Miller generator, and both retain the same sequence.
 */
 
-:- module(random, [maybe/0, random/1, random/3, random_integer/3, set_random/1]).
+:- module(random, [maybe/0, maybe/1, maybe/2, random/1, random/3, random_integer/3, set_random/1]).
 
 :- use_module(library(iso_ext), [bb_get/2, bb_put/2]).
 :- use_module(library(error), [instantiation_error/1, type_error/3]).
@@ -15,6 +15,15 @@
 maybe :-
     random_integer(0, 2, 0).
 
+maybe(Probability) :-
+    random(Value),
+    Value < Probability.
+
+maybe(K, N) :-
+    Probability is K / N,
+    random(Value),
+    Value < Probability.
+
 
 random(Value) :-
     eyeprolog__random_value(Value).

package/src/lib/tabling.pl

@@ -2,10 +2,10 @@
 
     EyeProlog tables predicates only when requested explicitly with
     `:- table ...`.  The library keeps the portable start_tabling/2 and
-    abolish_all_tables/0 surface used by Scryer/Trealla-compatible source.
+    abolish_all_tables/0 and abolish_table/1 surface used by Scryer/Trealla-compatible source.
 */
 
-:- module(tabling, [start_tabling/2, abolish_all_tables/0, op(1150, fx, table)]).
+:- module(tabling, [start_tabling/2, abolish_all_tables/0, abolish_table/1, op(1150, fx, table)]).
 
 :- meta_predicate(start_tabling(?, 0)).
 
@@ -14,3 +14,24 @@ start_tabling(_, Worker) :-
 
 abolish_all_tables :-
     eyeprolog__abolish_all_tables.
+
+
+abolish_table(Spec) :-
+    ( var(Spec) -> throw(error(instantiation_error, abolish_table/1))
+    ; tabling__abolish_table(Spec)
+    ).
+
+tabling__abolish_table((A,B)) :- !,
+    tabling__abolish_table(A),
+    tabling__abolish_table(B).
+tabling__abolish_table(Name//Arity) :-
+    atom(Name), integer(Arity), Arity >= 0, !,
+    ExpandedArity is Arity + 2,
+    tabling__abolish_table(Name/ExpandedArity).
+tabling__abolish_table(Name/Arity) :-
+    atom(Name), integer(Arity), Arity >= 0, !,
+    ( eyeprolog__abolish_table(Name, Arity) -> true
+    ; throw(error(existence_error(table, Name/Arity), abolish_table/1))
+    ).
+tabling__abolish_table(Spec) :-
+    throw(error(type_error(predicate_indicator, Spec), abolish_table/1)).

package/src/library-autoload-index.js

@@ -50,10 +50,13 @@ export const eyePrologLibraryAutoload = Object.freeze({
   "$-/1": "debug",
   "$/1": "debug",
   "abolish_all_tables/0": "tabling",
+  "abolish_table/1": "tabling",
   "add_edges/3": "ugraphs",
   "add_vertices/3": "ugraphs",
+  "aggregate_all/3": "aggregate",
   "aggregate_max/5": "aggregate",
   "aggregate_min/5": "aggregate",
+  "aggregate/3": "aggregate",
   "all_different/1": "clpz",
   "all_distinct/1": "clpz",
   "append/2": "lists",
@@ -139,6 +142,7 @@ export const eyePrologLibraryAutoload = Object.freeze({
   "edges/2": "ugraphs",
   "element/3": "clpz",
   "empty_assoc/1": "assoc",
+  "exclude/3": "lists",
   "expmod/4": "arithmetic",
   "fd_dom/2": "clpz",
   "fd_inf/2": "clpz",
@@ -161,6 +165,7 @@ export const eyePrologLibraryAutoload = Object.freeze({
   "format/2": "format",
   "format/3": "format",
   "freeze/2": "freeze",
+  "frozen/2": "freeze",
   "ge/2": "comparison",
   "gen_assoc/3": "assoc",
   "gen_int/1": "between",
@@ -181,13 +186,16 @@ export const eyePrologLibraryAutoload = Object.freeze({
   "hex_bytes/2": "crypto",
   "if_/3": "reif",
   "in/2": "clpz",
+  "include/3": "lists",
   "indomain/1": "clpz",
   "ins/2": "clpz",
   "instantiation_error/0": "error",
   "instantiation_error/1": "error",
   "integer_si/1": "si",
+  "intersection/3": "lists",
   "is_assoc/1": "assoc",
   "is_ordset/1": "ordsets",
+  "is_set/1": "lists",
   "join/3": "strings",
   "label/1": "clpz",
   "labeling/1": "clpb",
@@ -226,6 +234,8 @@ export const eyePrologLibraryAutoload = Object.freeze({
   "max_list/2": "lists",
   "max_sleep_time/1": "time",
   "maybe/0": "random",
+  "maybe/1": "random",
+  "maybe/2": "random",
   "member/2": "lists",
   "memberchk/2": "lists",
   "memberd_t/3": "reif",
@@ -309,12 +319,14 @@ export const eyePrologLibraryAutoload = Object.freeze({
   "representation_error/1": "error",
   "reset_gensym/1": "gensym",
   "resource_error/1": "error",
+  "resource_error/2": "error",
   "reverse/2": "lists",
   "same_length/2": "lists",
   "sat_count/2": "clpb",
   "sat/1": "clpb",
   "scalar_product/4": "clpz",
   "select/3": "lists",
+  "selectchk/3": "lists",
   "seq/3": "dcgs",
   "seqq/3": "dcgs",
   "serialized/2": "clpz",
@@ -333,11 +345,19 @@ export const eyePrologLibraryAutoload = Object.freeze({
   "statistics/2": "time",
   "string_concat/3": "strings",
   "substring/4": "strings",
+  "subtract/3": "lists",
   "succ/2": "iso_ext",
   "sum_list/2": "lists",
   "sum/3": "clpz",
   "sumall/3": "aggregate",
   "take/3": "lists",
+  "tasklist/2": "lists",
+  "tasklist/3": "lists",
+  "tasklist/4": "lists",
+  "tasklist/5": "lists",
+  "tasklist/6": "lists",
+  "tasklist/7": "lists",
+  "tasklist/8": "lists",
   "taut/2": "clpb",
   "term_attributed_variables/2": "atts",
   "term_si/1": "si",
@@ -357,6 +377,7 @@ export const eyePrologLibraryAutoload = Object.freeze({
   "type_error/2": "error",
   "type_error/3": "error",
   "ugraph_union/3": "ugraphs",
+  "union/3": "lists",
   "unsetenv/1": "os",
   "uppercase/2": "strings",
   "uuid_string/2": "uuid",

package/src/standard-library.js

@@ -121,8 +121,8 @@ export const eyePrologNativeLibraryIndicators = Object.freeze([
   'random/1',
 ]);
 export const eyePrologPortableLibraryIndicators = Object.freeze([
-  'sumall/3', 'aggregate_min/5', 'aggregate_max/5',
-  'freeze/2',
+  'sumall/3', 'aggregate_min/5', 'aggregate_max/5', 'aggregate_all/3', 'aggregate/3',
+  'freeze/2', 'frozen/2',
   'expmod/4', 'lcm/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',
@@ -141,7 +141,7 @@ export const eyePrologPortableLibraryIndicators = Object.freeze([
   '*/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',
+  'representation_error/1', 'resource_error/1', 'resource_error/2', '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',
@@ -150,10 +150,11 @@ export const eyePrologPortableLibraryIndicators = Object.freeze([
   '^/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',
+  'member/2', 'memberchk/2', 'select/3', 'selectchk/3', 'subtract/3', 'union/3', 'intersection/3', 'is_set/1', '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', 'maplist/9', 'foldl/4', 'foldl/5', 'foldl/6',
+  'length/2', 'exclude/3', 'include/3', 'maplist/2', 'maplist/3', 'maplist/4', 'maplist/5',
+  'maplist/6', 'maplist/7', 'maplist/8', 'maplist/9',
+  'tasklist/2', 'tasklist/3', 'tasklist/4', 'tasklist/5', 'tasklist/6', 'tasklist/7', 'tasklist/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',
@@ -166,7 +167,7 @@ export const eyePrologPortableLibraryIndicators = Object.freeze([
   'phrase_from_file/2', 'phrase_from_file/3', 'phrase_from_stream/2', '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',
+  'maybe/0', 'maybe/1', 'maybe/2', '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',
@@ -175,7 +176,7 @@ export const eyePrologPortableLibraryIndicators = Object.freeze([
   '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',
+  'start_tabling/2', 'abolish_all_tables/0', 'abolish_table/1',
   'max_sleep_time/1', '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',

package/src/tabling-host.js

@@ -1,4 +1,6 @@
-// Runtime table-cache lifecycle adapter for library(tabling).
+// Runtime table-cache lifecycle adapters for library(tabling).
+
+import { ATOM, NUMBER, deref } from './term.js';
 
 function* abolishAllTablesBuiltin({ solver, env }) {
   solver.memo.clear();
@@ -15,8 +17,43 @@ function* abolishAllTablesBuiltin({ solver, env }) {
   yield env;
 }
 
+function clearPredicateFromMemo(memo, prefix) {
+  for (const key of [...memo.keys()]) {
+    if (key.startsWith(prefix)) memo.delete(key);
+  }
+}
+
+function clearPredicateTables(solver, module, name, arity) {
+  const broadKey = `${module}:${name}/${arity}`;
+  clearPredicateFromMemo(solver.memo, `${broadKey}:`);
+  solver.subsumptiveMemo.delete(broadKey);
+  for (const scope of solver.innerTableScopes.values()) {
+    clearPredicateFromMemo(scope.memo, `${broadKey}:`);
+    scope.subsumptiveMemo.delete(broadKey);
+  }
+}
+
+function* abolishTableBuiltin({ solver, goal, env }) {
+  const name = deref(goal.args[0], env);
+  const arity = deref(goal.args[1], env);
+  if (name.type !== ATOM || arity.type !== NUMBER || !/^\d+$/.test(arity.name)) return;
+  const arityValue = Number(arity.name);
+  const matches = [...solver.program.groups.values()].filter((group) =>
+    group.name === name.name && group.arity === arityValue && group.tabled === true);
+  if (matches.length === 0) return;
+  for (const group of matches) clearPredicateTables(solver, group.module, group.name, group.arity);
+  // A completed WFS/Datalog model can depend on a tabled predicate; these
+  // caches do not expose per-predicate dependency keys, so invalidate them
+  // conservatively while preserving unrelated explicit memo tables.
+  solver.wfsModels.clear();
+  solver.datalogModels.clear();
+  solver.tableCoordinator = null;
+  yield env;
+}
+
 export const tablingHostBuiltins = {
   register(registry) {
     registry.add('eyeprolog__abolish_all_tables', 0, abolishAllTablesBuiltin, { deterministic: true, eyePrologLibrary: true });
+    registry.add('eyeprolog__abolish_table', 2, abolishTableBuiltin, { deterministic: true, eyePrologLibrary: true });
   },
 };

package/test/run-architecture.mjs

@@ -57,6 +57,23 @@ export function runArchitecture(reporter = new TestReporter()) {
     }
     if (issues.length > 0) throw new Error(issues.join('\n'));
   });
+  reporter.test('overlapping bundled libraries cover the pinned Trealla export surface', () => {
+    const snapshotPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), 'trealla-library-exports.json');
+    const expected = JSON.parse(fs.readFileSync(snapshotPath, 'utf8'));
+    const issues = [];
+    for (const [module, indicators] of Object.entries(expected)) {
+      const file = path.join(ROOT, 'lib', `${module}.pl`);
+      if (!fs.existsSync(file)) {
+        issues.push(`missing src/lib/${module}.pl`);
+        continue;
+      }
+      const actual = new Set(moduleExportIndicators(fs.readFileSync(file, 'utf8'), `src/lib/${module}.pl`));
+      for (const indicator of indicators) {
+        if (!actual.has(indicator)) issues.push(`${module}: missing Trealla export ${indicator}`);
+      }
+    }
+    if (issues.length > 0) throw new Error(issues.join('\n'));
+  });
   reporter.test('legacy grab-bag library host files are absent', () => {
     for (const name of ['library-host.js', 'scryer-compat.js']) {
       if (fs.existsSync(path.join(ROOT, name))) throw new Error(`${name} must stay split into module-owned hosts`);