eyeprolog 1.5.11 → 1.5.13

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.11",
+  "version": "1.5.13",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",

package/src/execute.js

@@ -51,6 +51,7 @@ export function executeGoals(program, solver, goals, { onAnswer = () => {} } = {
 function currentWriteOptions(program, solver) {
   return {
     doubleQuotes: solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
+    doubleBar: !solver.isoStrict,
     operators: [...program.operators.values()],
     quoted: true,
   };

package/src/iso.js

@@ -1988,6 +1988,7 @@ function writeBuiltin(mode) {
       generateVariableNames: true,
       variableNameState: solver.writeVariableState,
       operators: solver.program.operators.values(),
+      doubleBar: !solver.isoStrict,
     }));
     yield env;
   };
@@ -2019,6 +2020,7 @@ function* writeTermBuiltin({ solver, goal, env }) {
     generateVariableNames: true,
     variableNameState: solver.writeVariableState,
     operators: solver.program.operators.values(),
+    doubleBar: !solver.isoStrict,
   }));
   yield env;
 }

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/parser.js

@@ -937,9 +937,37 @@ class Parser {
         this.parserFlagState.doubleQuotes === 'chars'
           ? atom(character)
           : numberTerm(character.codePointAt(0)));
-      let list = emptyList();
-      for (let i = items.length - 1; i >= 0; i--) list = cons(items[i], list);
-      return list;
+      let tail = emptyList();
+
+      // Trealla-compatible double-bar right splice (issue #88): in normal
+      // mode, a double-quoted chars/codes prefix may be followed by `||Tail`.
+      // It is equivalent to the corresponding list prefix with Tail as its
+      // final list tail, e.g. "ab"||T is [a,b|T] with double_quotes(chars).
+      // The extension binds at priority 1 (tighter than ordinary operators)
+      // and is deliberately absent from the strict ISO profile.
+      if (!this.strictIso && this.token.type === TOK.BAR) {
+        const state = {
+          pos: this.pos,
+          line: this.line,
+          previousToken: this.previousToken,
+          token: this.token,
+        };
+        this.advance();
+        if (this.token.type === TOK.BAR) {
+          this.advance();
+          tail = this.parseTerm(operatorStrength(1), false, allowBar, false);
+        } else {
+          // A single bar remains ordinary bar syntax. We had to advance once
+          // to distinguish it from `||`, so restore the tokenizer state.
+          this.pos = state.pos;
+          this.line = state.line;
+          this.previousToken = state.previousToken;
+          this.token = state.token;
+        }
+      }
+
+      for (let i = items.length - 1; i >= 0; i--) tail = cons(items[i], tail);
+      return tail;
     }
     if (this.token.type === TOK.NUMBER) {
       const value = this.token.text;

package/src/repl.js

@@ -746,6 +746,7 @@ function formatAnswer(engine, state, variables, env) {
     operatorAtomsAsArgs: true,
     dottedGraphicAtoms: true,
     doubleQuotes: state.solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
+    doubleBar: !state.strictIso,
   };
   let generated = 0;
 
@@ -844,6 +845,7 @@ function formatError(engine, state, error) {
       quoted: true,
       operators: [...state.program.operators.values()],
       variableNames,
+      doubleBar: !state.strictIso,
     })}.`;
   }
   const message = error?.message ?? String(error);

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/src/term.js

@@ -1067,14 +1067,18 @@ function writeString(value, quoteStrings) {
   return out + '"';
 }
 
-function quotedListText(term, env, doubleQuotes) {
+function quotedListSplice(term, env, doubleQuotes) {
   if (doubleQuotes !== 'chars' && doubleQuotes !== 'codes') return null;
   const characters = [];
   let cursor = term;
   while (true) {
     cursor = deref(cursor, env);
-    if (isEmptyList(cursor)) return characters.length === 0 ? null : characters.join('');
-    if (!isCons(cursor)) return null;
+    if (isEmptyList(cursor)) {
+      return characters.length === 0 ? null : { text: characters.join(''), tail: null };
+    }
+    if (!isCons(cursor)) {
+      return characters.length === 0 ? null : { text: characters.join(''), tail: cursor };
+    }
     const item = deref(cursor.args[0], env);
     if (doubleQuotes === 'chars') {
       if (item.type !== ATOM || Array.from(item.name).length !== 1) return null;
@@ -1090,8 +1094,12 @@ function quotedListText(term, env, doubleQuotes) {
 }
 
 function writeList(term, env, options) {
-  const quotedText = quotedListText(term, env, options.doubleQuotes);
-  if (quotedText != null) return writeString(quotedText, true);
+  const quotedSplice = quotedListSplice(term, env, options.doubleQuotes);
+  if (quotedSplice != null && (quotedSplice.tail == null || options.doubleBar === true)) {
+    const prefix = writeString(quotedSplice.text, true);
+    if (quotedSplice.tail == null) return prefix;
+    return `${prefix}||${termToString(quotedSplice.tail, env, true, options)}`;
+  }
   const parts = [];
   let cursor = term;
   while (true) {
@@ -1110,6 +1118,10 @@ export function termToString(term, env = new Env(), quoteStrings = true, options
   options = {
     ...options,
     doubleQuotes: options.doubleQuotes ?? 'chars',
+    // termToString is also used for context-free processor-error messages.
+    // Keep the normal-profile `||` extension opt-in here so strict errors do
+    // not accidentally emit syntax that the strict parser rejects.
+    doubleBar: options.doubleBar === true,
     readVariableNames: options.readVariableNames instanceof Map ? options.readVariableNames : new Map(),
     usedReadVariableNames: options.usedReadVariableNames instanceof Set ? options.usedReadVariableNames : new Set(),
   };

package/src/write.js

@@ -152,14 +152,18 @@ function writeString(value) {
   return out + '"';
 }
 
-function quotedListText(term, env, doubleQuotes) {
+function quotedListSplice(term, env, doubleQuotes) {
   if (doubleQuotes !== 'chars' && doubleQuotes !== 'codes') return null;
   const characters = [];
   let cursor = term;
   while (true) {
     cursor = deref(cursor, env);
-    if (isEmptyList(cursor)) return characters.length === 0 ? null : characters.join('');
-    if (!isCons(cursor)) return null;
+    if (isEmptyList(cursor)) {
+      return characters.length === 0 ? null : { text: characters.join(''), tail: null };
+    }
+    if (!isCons(cursor)) {
+      return characters.length === 0 ? null : { text: characters.join(''), tail: cursor };
+    }
     const item = deref(cursor.args[0], env);
     if (doubleQuotes === 'chars') {
       if (item.type !== ATOM || Array.from(item.name).length !== 1) return null;
@@ -331,8 +335,15 @@ function format(term, env, options, table, maxPriority = 1200, context = 'term')
   }
 
   if (!options.ignoreOps && isCons(resolved)) {
-    const quotedText = quotedListText(resolved, env, options.doubleQuotes);
-    if (quotedText != null) return writeString(quotedText);
+    const quotedSplice = quotedListSplice(resolved, env, options.doubleQuotes);
+    if (quotedSplice != null && (quotedSplice.tail == null || options.doubleBar)) {
+      const prefix = writeString(quotedSplice.text);
+      if (quotedSplice.tail == null) return prefix;
+      // `||` is a normal-profile syntax extension with priority 1, so a
+      // looser operator in the right operand must be parenthesized to keep the
+      // emitted text readable as the same term.
+      return `${prefix}||${format(quotedSplice.tail, env, options, table, 1, 'term')}`;
+    }
     const parts = [];
     let cursor = resolved;
     while (true) {
@@ -442,6 +453,9 @@ export function formatTermForWrite(term, env = new Env(), options = {}) {
     ignoreOps: options.ignoreOps === true,
     numbervars: options.numbervars !== false,
     doubleQuotes: options.doubleQuotes,
+    // `||` is a normal-profile syntax extension. Public normal-mode writers
+    // enable it by default; strict callers explicitly turn it off.
+    doubleBar: options.doubleBar !== false,
     variableNames: options.generateVariableNames === true
       ? printableGeneratedVariableNames(term, env, explicitVariableNames, options.variableNameState)
       : printableReadVariableNames(term, env, explicitVariableNames),

package/test/conformance/ISO-IMPLEMENTATION-DEFINED.md

@@ -113,7 +113,7 @@ families; `--iso-strict` is intended to remove their Part 1 interpretation.
 
 | Part 1 extension hook | EyeProlog normal-profile feature | Strict-core disposition |
 | --- | --- | --- |
-| 5.5.1 Syntax | Part 2 modules, Part 3 grammar-rule expansion, and embedded quad syntax | Module directives are rejected; grammar rules remain ordinary `-->/2` terms rather than being expanded; quad syntax is rejected. Unicode PCS membership/classification is implementation defined and therefore shared with normal mode rather than treated as an extension. |
+| 5.5.1 Syntax | Part 2 modules, Part 3 grammar-rule expansion, embedded quad syntax, and Trealla-compatible `"text"||Tail` right-splicing for double-quoted `chars`/`codes` lists | Module directives are rejected; grammar rules remain ordinary `-->/2` terms rather than being expanded; quad syntax and double-bar right-splicing are rejected. Unicode PCS membership/classification is implementation defined and therefore shared with normal mode rather than treated as an extension. |
 | 5.5.2 Predefined operators | Part 3 `|` and EyeProlog's labelable infix `(?-)/2`; CLP(Z) operators when that library is imported | Only the Part 1 operator table is predefined; a conforming `op/3` may still add permitted operators. |
 | 5.5.3 Character-conversion mapping | No non-identity initial `Convc` extension | Identity initial mapping. |
 | 5.5.4 Types | The normal JavaScript API exposes an implementation-specific string term `stringTerm(Text)`. It is disjoint from the five Part 1 term types; normal term order places it after atoms and before compound terms, and normal `atomic/1` treats it as atomic. It has no Prolog source token syntax (double-quoted source still follows `double_quotes`), is non-callable for term-to-clause conversion, is not evaluable as an arithmetic expression, and writes as a double-quoted host string. | Strict mode rejects a programmatic string term at program/goal entry with `representation_error(term)`, so the additional type cannot enter the Part 1 execution domain. **defined** — `src/term.js`, `src/program.js`, `src/solver.js`; strict API-boundary regression. |

package/test/conformance/expected/iso/scryer_lexical_terms.pl

@@ -1,4 +1,4 @@
 scryer_escapes(ok).
 scryer_numbers(-1, 1, 1, 1, 1).
 scryer_comments(7, 7).
-scryer_terms({1}, "a", [a, b | c], []).
+scryer_terms({1}, "a", "ab"||c, []).

package/test/conformance/expected/lists/extra_append_to_improper_tail.pl

@@ -1 +1 @@
-answer(append_to_improper_tail, [a, b | tail]).
+answer(append_to_improper_tail, "ab"||tail).

package/test/conformance/expected/lists/improper_list_readback.pl

@@ -1 +1 @@
-answer([a, b | tail]).
+answer("ab"||tail).

package/test/conformance/expected/terms/003_terms_and_readback.pl

@@ -10,4 +10,4 @@ value(compound, pair(3, nested(atom, "xy"))).
 value(arity_zero_atom, nil).
 value(empty_list, []).
 value(proper_list, "abc").
-value(improper_list, [a, b | tail]).
+value(improper_list, "ab"||tail).

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`);

package/test/run-regression.mjs

@@ -2441,7 +2441,7 @@ c4 ?- call((!;1)).
           '?-    Xs = [].\n' +
           '?-    true.\n' +
           '?-    true.\n' +
-          '?-    Xs0 = [a | Xs].\n' +
+          '?-    Xs0 = "a"||Xs.\n' +
           '?- ',
           'stdout');
         assertEqual(result.stderr, '', 'stderr');
@@ -6493,7 +6493,7 @@ answer(ok) :-
         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, 215, 'EyeProlog registry contains ISO definitions, cleanup controls, observability extensions, WFS tnot/1, and generic library adapters');
+        assertEqual(library.defs.size, 216, 'EyeProlog registry contains ISO definitions, cleanup controls, observability extensions, WFS tnot/1, and generic library adapters');
         assertEqual(registry.get('eyeprolog__dynify', 1), null, 'Eyelet dynify adapter is absent from the ISO registry');
         assertEqual(Boolean(library.get('eyeprolog__dynify', 1)), true, 'Eyelet dynify adapter is an internal EyeProlog library primitive');
         assertEqual(registry.get('eyeprolog__eyelet_emit', 2), null, 'Eyelet event adapter is absent from the ISO registry');
@@ -6517,7 +6517,7 @@ answer(ok) :-
         assertEqual(registry.get('setup_call_cleanup', 3), null, 'setup_call_cleanup/3 is absent from the ISO registry');
         assertEqual(Boolean(library.get('setup_call_cleanup', 3)), true, 'setup_call_cleanup/3 is an EyeProlog cleanup control');
         assertEqual(registeredNativeEyePrologLibraryNames().length, 109, 'public host-supported EyeProlog library count');
-        assertEqual(eyePrologPortableLibraryIndicators.length, 259, 'portable Prolog library count');
+        assertEqual(eyePrologPortableLibraryIndicators.length, 280, 'portable Prolog library count');
         assertEqual(eyePrologInteropLibraryIndicators.length, 218, 'cross-implementation interop profile count');
         assertEqual(eyePrologInteropLibraryModules.length, 26, 'common explicit library module profile count');
         assertEqual(eyePrologInteropAutoload['member/2'], 'lists', 'member/2 canonical autoload');
@@ -6535,7 +6535,7 @@ answer(ok) :-
         assertEqual(eyePrologNativeLibraryIndicators.length, 109, 'host-supported library count');
         assertEqual(eyePrologNativeLibraryIndicators.includes('call_nth/2'), true, 'call_nth/2 remains classified as host-supported');
         assertEqual(eyePrologNativeLibraryIndicators.includes('random/1'), true, 'stateful random/1 is classified as host-supported');
-        assertEqual(eyePrologLibraryIndicators.length, 368, 'complete non-ISO EyeProlog library surface');
+        assertEqual(eyePrologLibraryIndicators.length, 389, 'complete non-ISO EyeProlog library surface');
         assertEqual(registry.get('eyeprolog__call_nth', 2), null, 'private call_nth adapter is absent from ISO registry');
         assertEqual(Boolean(library.get('eyeprolog__call_nth', 2)), true, 'private call_nth adapter is registered for EyeProlog');
         assertEqual(Boolean(library.get('eyeprolog__call_residue_vars', 2)), true, 'private call_residue_vars adapter is registered for EyeProlog');
@@ -6588,6 +6588,51 @@ answer(ok) :-
         assertEqual(program.findGroup('random', 3)?.module, 'random', 'random/3 is imported from library(random)');
       },
     },
+    {
+      name: 'Trealla library overlap predicates execute with EyeProlog semantics',
+      run: () => {
+        const program = Program.parse(`
+:- use_module(library(aggregate)).
+:- use_module(library(error)).
+:- use_module(library(freeze)).
+:- use_module(library(lists)).
+:- use_module(library(random)).
+:- use_module(library(tabling)).
+
+positive(X) :- X > 0.
+inc(X, Y) :- Y is X + 1.
+
+:- dynamic(edge/2).
+:- table(path/2).
+path(X, Y) :- edge(X, Y).
+path(X, Z) :- edge(X, Y), path(Y, Z).
+
+trealla_overlap_probe :-
+    aggregate_all(count, member(_, [a,b,c]), 3),
+    aggregate_all(sum(X), member(X, [1,2,3]), 6),
+    aggregate_all(bag(X), member(X, [a,b]), [a,b]),
+    aggregate_all(set(X), member(X, [b,a,b]), [a,b]),
+    aggregate(sum(X), member(K-X, [a-1,a-2,b-3]), 3), K = a,
+    aggregate(sum(Y), J^member(J-Y, [a-1,a-2,b-3]), 6),
+    selectchk(b, [a,b,c], [a,c]),
+    subtract([a,b,a,c], [a], [b,c]),
+    union([a,b], [b,c], [a,b,c]),
+    intersection([a,b,c], [b,d,c], [b,c]),
+    is_set([a,b,c]), \\+ is_set([a,a]),
+    include(positive, [-1,2,0,3], [2,3]),
+    exclude(positive, [-1,2,0,3], [-1,0]),
+    tasklist(inc, [1,2,3], [2,3,4]),
+    maybe(1.0), maybe(1, 1),
+    freeze(F, true), frozen(F, Frozen), Frozen \\== true, F = ready,
+    catch(resource_error(memory, context), error(resource_error(memory), context), true),
+    assertz(edge(a,b)), path(a,b),
+    retract(edge(a,b)), assertz(edge(a,c)),
+    abolish_table(path/2), \\+ path(a,b), path(a,c),
+    catch(abolish_table(missing/1), error(existence_error(table, missing/1), abolish_table/1), true).
+`);
+        assertEqual(run(program, { goal: 'trealla_overlap_probe' }).stdout, 'trealla_overlap_probe.\n', 'Trealla overlap execution');
+      },
+    },
     {
       name: 'Prologue facade re-exports canonical library predicates without conflicts',
       run: () => {
@@ -6947,6 +6992,44 @@ function whiteBoxCases() {
         assertEqual(`${quotedAtom.type}:${quotedAtom.name}`, 'atom:aλ', 'atom');
       },
     },
+    {
+      name: 'double-bar syntax splices double-quoted list prefixes (issue #88)',
+      run: () => {
+        const chars = parseGoalText('p("ab"||Tail)').args[0];
+        assertEqual(chars.args[0].name, 'a', 'chars first element');
+        assertEqual(chars.args[1].args[0].name, 'b', 'chars second element');
+        assertEqual(chars.args[1].args[1].type, 'var', 'chars partial tail type');
+        assertEqual(chars.args[1].args[1].name, 'Tail', 'chars partial tail name');
+        assertEqual(termToString(chars, new Env(), true, { doubleBar: true }), '"ab"||Tail', 'chars readback');
+
+        const codes = parseGoalText('p("aλ" || Tail)', { doubleQuotes: 'codes' }).args[0];
+        assertEqual(codes.args[0].name, '97', 'codes first element');
+        assertEqual(codes.args[1].args[0].name, '955', 'codes second element');
+        assertEqual(termToString(codes, new Env(), true, { doubleQuotes: 'codes', doubleBar: true }), '"aλ"||Tail', 'codes readback');
+
+        const nested = parseGoalText('p(["ab"|Tail])');
+        assertEqual(termToString(nested), 'p(["ab" | Tail])', 'single bar remains list syntax');
+
+        for (const options of [{ isoStrict: true }, { doubleQuotes: 'atom' }]) {
+          let threw = false;
+          try { parseGoalText('p("ab"||Tail)', options); } catch (_) { threw = true; }
+          assertEqual(threw, true, `double-bar rejected for ${JSON.stringify(options)}`);
+        }
+      },
+    },
+    {
+      name: 'REPL prints partial character lists with double-bar syntax (issue #88)',
+      run: () => {
+        const result = runCli([], {
+          input: 'phrase("Think of this text, and much more.", S0,S).\nhalt.\n',
+        });
+        assertEqual(result.status, 0, 'REPL exit status');
+        assertIncludes(result.stdout,
+          'S0 = "Think of this text, and much more."||S.',
+          'Trealla-compatible partial string answer');
+        assertNotIncludes(result.stdout, "S0 = ['T'", 'legacy expanded list answer');
+      },
+    },
     {
       name: 'double_quotes directives affect subsequent source text',
       run: () => {

package/test/trealla-library-exports.json

@@ -0,0 +1,28 @@
+{
+  "aggregate": ["aggregate_all/3", "aggregate/3"],
+  "arithmetic": ["lsb/2", "msb/2", "popcount/2", "number_to_rational/2", "rational_numerator_denominator/3"],
+  "assoc": ["empty_assoc/1", "is_assoc/1", "assoc_to_list/2", "assoc_to_keys/2", "assoc_to_values/2", "gen_assoc/3", "get_assoc/3", "get_assoc/5", "list_to_assoc/2", "map_assoc/2", "map_assoc/3", "max_assoc/3", "min_assoc/3", "ord_list_to_assoc/2", "put_assoc/4", "del_assoc/4", "del_min_assoc/4", "del_max_assoc/4"],
+  "atts": ["get_attr/3", "put_attr/3", "del_attr/2"],
+  "charsio": ["char_type/2", "get_line_to_chars/3", "get_single_char/1", "get_n_chars/3"],
+  "clpb": ["sat/1", "taut/2", "labeling/1", "sat_count/2", "weighted_maximum/3", "random_labeling/2"],
+  "clpz": ["#>/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", "element/3", "automaton/3", "automaton/8", "zcompare/3", "chain/2", "fd_var/1", "fd_inf/2", "fd_sup/2", "fd_size/2", "fd_dom/2", "clpz_t/2", "#=/3", "#</3"],
+  "debug": ["*/1", "$/1", "$-/1"],
+  "dif": ["dif/2"],
+  "error": ["must_be/2", "can_be/2", "instantiation_error/0", "domain_error/2", "type_error/2", "representation_error/1", "resource_error/1", "resource_error/2", "instantiation_error/1", "domain_error/3", "type_error/3", "call_with_error_context/2"],
+  "format": ["format_/4", "format/2", "format/3", "portray_clause_/3", "portray_clause/1", "portray_clause/2", "listing/1"],
+  "freeze": ["freeze/2", "frozen/2"],
+  "gensym": ["gensym/2", "reset_gensym/1"],
+  "lambda": ["^/3", "^/4", "^/5", "^/6", "^/7", "^/8", "^/9", "^/10", "\\/1", "\\/2", "\\/3", "\\/4", "\\/5", "\\/6", "\\/7", "\\/8", "+\\/2", "+\\/3", "+\\/4", "+\\/5", "+\\/6", "+\\/7", "+\\/8", "+\\/9"],
+  "lists": ["member/2", "memberchk/2", "select/3", "selectchk/3", "append/2", "append/3", "subtract/3", "union/3", "intersection/3", "is_set/1", "nth1/3", "nth0/3", "nth1/4", "nth0/4", "last/2", "same_length/2", "transpose/2", "sum_list/2", "max_list/2", "min_list/2", "list_to_set/2", "reverse/2", "exclude/3", "include/3", "permutation/2", "foldl/4", "foldl/5", "foldl/6", "maplist/2", "maplist/3", "maplist/4", "maplist/5", "maplist/6", "maplist/7", "maplist/8", "tasklist/2", "tasklist/3", "tasklist/4", "tasklist/5", "tasklist/6", "tasklist/7", "tasklist/8"],
+  "ordsets": ["is_ordset/1", "list_to_ord_set/2", "ord_add_element/3", "ord_del_element/3", "ord_selectchk/3", "ord_intersect/2", "ord_intersect/3", "ord_intersection/3", "ord_intersection/4", "ord_disjoint/2", "ord_subtract/3", "ord_union/2", "ord_union/3", "ord_union/4", "ord_subset/2", "ord_empty/1", "ord_memberchk/2", "ord_symdiff/3", "ord_seteq/2", "ord_intersection/2"],
+  "pairs": ["pairs_keys_values/3", "pairs_keys/2", "pairs_values/2", "group_pairs_by_key/2", "map_list_to_pairs/3"],
+  "pio": ["phrase_from_file/2", "phrase_from_file/3", "phrase_to_file/2", "phrase_to_file/3", "phrase_to_stream/2"],
+  "random": ["maybe/0", "maybe/1", "maybe/2", "random_integer/3", "set_random/1"],
+  "reif": ["if_/3", "=/3", ",/3", ";/3", "cond_t/3", "dif/3", "memberd_t/3", "tfilter/3", "tmember/2", "tmember_t/3", "tpartition/4"],
+  "si": ["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"],
+  "tabling": ["start_tabling/2", "abolish_all_tables/0", "abolish_table/1"],
+  "time": ["current_time/1", "format_time/4"],
+  "ugraphs": ["add_edges/3", "add_vertices/3", "complement/2", "compose/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", "vertices/2", "vertices_edges_to_ugraph/3", "ugraph_union/3", "connect_ugraph/3"],
+  "uuid": ["uuidv4/1", "uuidv4_string/1", "uuid_string/2"],
+  "when": ["when/2"]
+}

package/the-art-of-eyeprolog.md

@@ -474,6 +474,12 @@ Prolog programs accepted by EyeProlog are built from terms:
 - compound terms: `point(3, 4)`, `reading(temp, 91)`;
 - lists: `[]`, `[red, green, blue]`, `[Head | Tail]`.
 
+In normal mode, double-quoted character/code lists also support Trealla's
+right-splice notation. With `double_quotes(chars)`, `"ab"||Tail` is shorthand
+for `[a,b|Tail]`; with `double_quotes(codes)`, it denotes `[97,98|Tail]`. The
+splice is not available when `double_quotes(atom)` is active, and
+`--iso-strict` rejects it as an implementation-specific syntax extension.
+
 Plain atom constants begin with a lowercase ASCII letter. Variables begin with
 an uppercase letter or underscore. The bare `_` is anonymous and every
 occurrence is fresh. `_Name` is a named variable; repeated occurrences refer to
@@ -5492,8 +5498,10 @@ still retained where adjacent graphic tokens would otherwise merge, as in
 `write_term/2-3` supports `quoted/1`, `ignore_ops/1`, `numbervars/1`, and
 `variable_names/1`. Normal mode additionally accepts the EyeProlog extension
 `double_quotes(true|false)`: `true` lets eligible character/code lists use the
-current `double_quotes` representation, while strict ISO mode rejects this
-implementation-specific write option. Normal mode also accepts the
+current `double_quotes` representation. Proper lists can therefore be written
+as `"text"`, while a partial list such as `[a,b|Tail]` is written as
+`"ab"||Tail`. Strict ISO mode rejects this implementation-specific write
+option. Normal mode also accepts the
 implementation-specific boolean `spacing(true|false)` option: `false` emits
 only separators required to avoid lexical ambiguity, while `true` adds
 conventional layout around operators. For example,
@@ -5588,6 +5596,8 @@ lowercase ASCII letter. Variables begin with uppercase or underscore. The bare
 `_` is fresh each time. Single quotes delimit quoted atoms; double quotes use
 ISO double-quoted-list notation. Integers, decimals, scientific notation,
 binary/octal/hexadecimal integers, and character-code constants are accepted.
+Normal mode additionally accepts the Trealla-compatible `"text"||Tail`
+right-splice for double-quoted `chars`/`codes` lists; strict ISO mode does not.
 
 The processor character set is shared by normal and `--iso-strict` modes because
 Part 1 makes it implementation defined rather than an extension boundary.
@@ -6298,12 +6308,12 @@ so side effects occur in Prolog execution order.
 
 ### The EyeProlog library
 
-EyeProlog exposes **368 distinct non-ISO library and normal-extension predicate
+EyeProlog exposes **389 distinct non-ISO library and normal-extension predicate
 indicators** in addition to the 129 indicators in its isolated ISO profile.
-**259 are defined entirely as ordinary Prolog clauses** in focused modules under
+**280 are defined entirely as ordinary Prolog clauses** in focused modules under
 `src/lib/`; **109 use host support** for control, attributed variables,
 constraints, character conversion, filesystem/OS access, timing, cryptography,
-or observability. The ISO and library catalogs therefore cover **497 distinct predicate indicators**. A normal-runtime predicate that is intentionally
+or observability. The ISO and library catalogs therefore cover **518 distinct predicate indicators**. A normal-runtime predicate that is intentionally
 re-exported by a compatibility module is counted once in this library surface:
 for example `call_cleanup/2` and `setup_call_cleanup/3` are exported by
 `library(iso_ext)`, while `time/1` and `statistics/2` are available from
@@ -6382,7 +6392,7 @@ bindings make one aligned subterm pair sufficient. For example:
 
 | Module | Exported predicate indicators | Primary role |
 | --- | --- | --- |
-| `library(aggregate)` | `sumall/3`, `aggregate_min/5`, `aggregate_max/5` | Aggregation |
+| `library(aggregate)` | `sumall/3`, `aggregate_min/5`, `aggregate_max/5`, `aggregate_all/3`, `aggregate/3` | Aggregation, including Trealla-compatible aggregate templates |
 | `library(arithmetic)` | `expmod/4`, `lcm/3`, `lsb/2`, `msb/2`, `number_to_rational/2`, `number_to_rational/3`, `popcount/2`, `rational_numerator_denominator/3` | Scryer-compatible arithmetic helpers and rational-form conversion |
 | `library(assoc)` | `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` | AVL association trees; reused from the shared portable source |
 | `library(atts)` | `put_atts/2`, `get_atts/2`, `put_attr/3`, `get_attr/3`, `del_attr/2`, `term_attributed_variables/2`, `call_residue_vars/2` | Attributed variables |
@@ -6396,26 +6406,26 @@ bindings make one aligned subterm pair sufficient. For example:
 | `library(dcgs)` | `-->/2`, `.../2`, `phrase/2`, `phrase/3`, `phrase/4`, `phrase/5`, `seq/3`, `seqq/3` | Full Scryer DCG export surface; nonterminals are shown at their expanded arities |
 | `library(debug)` | `*/1`, `$/1`, `$-/1`, `debug/1`, `debug/3`, `nodebug/1`, `bb_get/2`, `bb_put/2`, `bb_b_put/2` | Declarative debug operators plus compatibility re-exports of the canonical `iso_ext` blackboard |
 | `library(dif)` | `dif/2` | Common module facade over native delayed disequality |
-| `library(error)` | `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` | Error checking and construction |
+| `library(error)` | `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`, `resource_error/2`, `call_with_error_context/2` | Error checking and construction |
 | `library(eyelet)` | `stable/1`, `becomes/2` | Eyelet forward-reasoning driver and state helpers; the `:+` operator is exported by the module and its fixed point is implemented in Prolog |
 | `library(files)` | `delete_directory/1`, `delete_file/1`, `directory_exists/1`, `directory_files/2`, `file_access_time/2`, `file_copy/2`, `file_creation_time/2`, `file_exists/1`, `file_modification_time/2`, `file_size/2`, `make_directory/1`, `make_directory_path/1`, `path_canonical/2`, `path_segments/2`, `rename_file/2`, `working_directory/2` | Full Scryer filesystem surface backed by the Node host where filesystem access is required |
 | `library(format)` | `format_/4`, `format/2`, `format/3`, `listing/1`, `portray_clause_/3`, `portray_clause/1`, `portray_clause/2` | Formatted DCG text and output; `format_/4` and `portray_clause_/3` are the expanded nonterminals |
-| `library(freeze)` | `freeze/2` | Delayed goals |
+| `library(freeze)` | `freeze/2`, `frozen/2` | Delayed goals and residual suspension inspection |
 | `library(gensym)` | `gensym/2`, `reset_gensym/1` | Process-local generated atoms |
 | `library(iso_ext)` | `bb_b_put/2`, `bb_get/2`, `bb_put/2`, `call_cleanup/2`, `call_nth/2`, `call_residue_vars/2`, `call_with_inference_limit/3`, `cfor/3`, `copy_term/3`, `copy_term_nat/2`, `countall/2`, `findall/4`, `forall/2`, `partial_string/1`, `partial_string/3`, `partial_string_tail/2`, `setup_call_cleanup/3`, `succ/2`, `time/1`, `variant/2` | Scryer ISO extensions plus EyeProlog compatibility helpers |
 | `library(lambda)` | `^/3`, `^/4`, `^/5`, `^/6`, `^/7`, `^/8`, `^/9`, `^/10`, `\/1`, `\/2`, `\/3`, `\/4`, `\/5`, `\/6`, `\/7`, `\/8`, `+\/2`, `+\/3`, `+\/4`, `+\/5`, `+\/6`, `+\/7`, `+\/8`, `+\/9` | Higher-order lambda notation |
-| `library(lists)` | `member/2`, `memberchk/2`, `select/3`, `append/2`, `append/3`, `last/2`, `same_length/2`, `nth0/3`, `nth0/4`, `nth1/3`, `nth1/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`, `sum_list/2`, `min_list/2`, `max_list/2`, `list_to_set/2`, `list_max/2`, `list_min/2`, `permutation/2`, `transpose/2`, `set_nth0/4`, `take/3`, `drop/3`, `slice/4` | List relations and shared matrix/permutation helpers |
+| `library(lists)` | `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`, `reverse/2`, `length/2`, `include/3`, `exclude/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`, `list_max/2`, `list_min/2`, `permutation/2`, `transpose/2`, `set_nth0/4`, `take/3`, `drop/3`, `slice/4` | List relations and shared matrix/permutation helpers; `tasklist/*` is a sequential compatibility fallback |
 | `library(ordsets)` | `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` | Ordered-set relations; reused upstream source |
 | `library(os)` | `argv/1`, `getenv/2`, `pid/1`, `raw_argv/1`, `setenv/2`, `shell/1`, `shell/2`, `unsetenv/1` | Environment, shell, PID, and command-line access backed by the Node host |
 | `library(pairs)` | `pairs_keys_values/3`, `pairs_keys/2`, `pairs_values/2`, `group_pairs_by_key/2`, `map_list_to_pairs/3` | Key-value pair support |
 | `library(pio)` | `phrase_from_file/2`, `phrase_from_file/3`, `phrase_from_stream/2`, `phrase_to_file/2`, `phrase_to_file/3`, `phrase_to_stream/2` | Scryer-compatible eager DCG file/stream I/O with character-list and atom paths |
 | `library(primes)` | `smallest_divisor_from/3` | Prime factor support |
 | `library(prologue)` | `member/2`, `append/3`, `length/2`, `between/3`, `select/3`, `succ/2`, `maplist/2`, `maplist/3`, `maplist/4`, `maplist/5`, `maplist/6`, `maplist/7`, `maplist/8`, `nth0/3`, `nth0/4`, `nth1/3`, `nth1/4`, `call_nth/2`, `freeze/2`, `foldl/4`, `foldl/5`, `foldl/6`, `countall/2` | Legacy facade over canonical focused modules |
-| `library(random)` | `maybe/0`, `random/1`, `random/3`, `random_integer/3`, `set_random/1` | Common mutable-seed interface plus EyeProlog's pure state-threaded generator |
+| `library(random)` | `maybe/0`, `maybe/1`, `maybe/2`, `random/1`, `random/3`, `random_integer/3`, `set_random/1` | Trealla-compatible probability helpers plus the common mutable-seed interface and EyeProlog's pure state-threaded generator |
 | `library(reif)` | `,/3`, `;/3`, `=/3`, `cond_t/3`, `dif/3`, `if_/3`, `memberd_t/3`, `tfilter/3`, `tmember/2`, `tmember_t/3`, `tpartition/4` | Reified conditions and list filtering; reused upstream source |
 | `library(si)` | `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` | Sufficient-instantiation checks used by CLP(Z) |
 | `library(strings)` | `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` | Text relations |
-| `library(tabling)` | `abolish_all_tables/0`, `start_tabling/2` | Common helpers for explicitly declared tabling |
+| `library(tabling)` | `abolish_all_tables/0`, `abolish_table/1`, `start_tabling/2` | Common helpers for explicitly declared tabling, including targeted invalidation |
 | `library(terms)` | `numbervars/3`, `copy_term_nat/2` | Term operations used by bundled libraries |
 | `library(time)` | `current_time/1`, `format_time/4`, `max_sleep_time/1`, `sleep/1`, `statistics/2`, `time/1` | Clock timestamps, sleep limits, timing/statistics, and the expanded `format_time//2` nonterminal |
 | `library(ugraphs)` | `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` | Directed graph relations; reused upstream source |
@@ -6452,7 +6462,13 @@ narrower than either implementation's union of exports; EyeProlog's explicit-sta
 interfaces. Separately, all 32 bundled EyeProlog modules whose basenames overlap
 Scryer's current `src/lib/` tree are checked against the frozen export snapshot in
 `test/scryer-library-exports.json` and cover the corresponding Scryer public
-predicate surface.
+predicate surface. The same structural check is now applied to Trealla: the 26
+bundled modules that have public-module counterparts in Trealla `library/` cover
+Trealla's exported predicates at pinned upstream commit
+`f7a93bd521c07a4841f5123348111dd005918c89`, recorded in
+`test/trealla-library-exports.json`. This is module-overlap coverage, not a claim
+that EyeProlog bundles Trealla's native host libraries such as `curl`, `gsl`,
+`janus`, `raylib`, `socket`, or `sqlite3`.
 
 Source reuse is preferred over translation. `clpb.pl`, `ordsets.pl`,
 `reif.pl`, and `ugraphs.pl` retain the upstream Prolog algorithms and license
@@ -6466,7 +6482,12 @@ compatibility. `files.pl` covers Scryer's complete filesystem export surface,
 while `os.pl` covers its environment/shell process-context surface. Their actual
 filesystem and OS side effects are isolated in module-owned Node adapters.
 `crypto.pl` exposes Scryer's complete public crypto surface; its strict Trealla/Scryer overlap is `hex_bytes/2`,
-`crypto_n_random_bytes/2`, and `crypto_data_hash/3`. The
+`crypto_n_random_bytes/2`, and `crypto_data_hash/3`. Trealla-specific overlap additions include `aggregate_all/3` and
+`aggregate/3`, `frozen/2`, the set/filter/list helpers and `tasklist/2-8`,
+`maybe/1-2`, `resource_error/2`, and `abolish_table/1`. Because EyeProlog has no
+Trealla task scheduler, `tasklist/2-8` deliberately executes sequentially with
+`maplist`-equivalent success/failure semantics; it does not promise Trealla's
+parallel scheduling behavior. The
 [portable library overlap example](https://github.com/eyereasoner/eyeprolog/blob/main/examples/portable-library-overlap.pl)
 composes Boolean constraints, ordered sets, graphs, reification, delayed goals,
 generated names, character conversion, transposition, and explicit table
@@ -8017,7 +8038,9 @@ Notable implementation boundaries are:
 - module and ISO/IEC TS 13211-3-oriented DCG compatibility profiles are supported in normal mode, without a complete Part 2/Part 3 certification claim;
 - variables cannot occupy functor or predicate position;
 - double-quoted text follows `double_quotes` exactly; the default `chars` value
-  matches Trealla and Scryer and may be changed to `codes` or `atom`;
+  matches Trealla and Scryer and may be changed to `codes` or `atom`; normal
+  mode additionally accepts Trealla-compatible `"text"||Tail` right-splicing
+  for the `chars` and `codes` values, while strict mode rejects that syntax;
 - `write_term/2-3` implements the Part 1 plus Corrigendum 3 `quoted/1`,
   `ignore_ops/1`, `numbervars/1`, and `variable_names/1` option surface,
   including option validation and traversal rules; normal mode also offers