eyeprolog 1.3.68 → 1.3.69

package/README.md

@@ -159,15 +159,17 @@ variable representatives and ordinary Prolog backtracking, and the REPL projects
 module `attribute_goals//1` hooks as residual goals. See
 [`examples/attributed-variables.pl`](examples/attributed-variables.pl).
 
-The second migration stage toward reusing Markus Triska's MIT-licensed
+The next two migration stages toward reusing Markus Triska's MIT-licensed
 [Scryer `library(clpz)`](https://github.com/mthom/scryer-prolog/blob/master/src/lib/clpz.pl)
-is now in place as well. Normal-profile loading supports user-defined
+are now in place as well. Normal-profile loading supports user-defined
 `term_expansion/2` and `goal_expansion/2`, clause-list generation, and
-`expand_term/2` for processor DCG lowering, including the qualified hook shape
-used by Scryer libraries. The current CLP(Z) implementation remains active while
-the remaining Scryer support-library surface is brought across. The staged plan
-and exact compatibility boundary are documented in
-[`src/CLPZ-MIGRATION.md`](src/CLPZ-MIGRATION.md).
+`expand_term/2` for processor DCG lowering. EyeProlog also ships the support
+modules used by Scryer's CLP(Z) source (`assoc`, `pairs`, `between`, `dcgs`,
+`terms`, `error`, `si`, `freeze`, `arithmetic`, `debug`, and `format`) together
+with generic backtrackable blackboard primitives. The current CLP(Z) engine
+remains active while the upstream solver itself is integrated and checked for
+behavioral and performance parity. The staged plan and exact compatibility
+boundary are documented in [`src/CLPZ-MIGRATION.md`](src/CLPZ-MIGRATION.md).
 
 Recursion through negation is explicit. EyeProlog provides `tnot/1` for
 well-founded negation over finite, range-restricted, function-free Datalog

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.3.68",
+  "version": "1.3.69",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",

package/src/ARCHITECTURE.md

@@ -48,6 +48,13 @@ needed by Scryer's `library(atts)` and `library(clpz)`. The current CLP(Z)-speci
 `Env._clpz` store remains transitional until the Scryer Prolog implementation can
 replace it without losing test or performance parity; see `src/CLPZ-MIGRATION.md`.
 
+`Env` also owns the small generic backtrackable blackboard used by Scryer-style
+libraries. Blackboard maps are shared by clones and copied only on write, so
+`bb_b_put/2` follows ordinary Prolog backtracking without any CLP(Z)-specific
+state in the VM. `scryer-compat.js` exposes the private host bridge used by
+`library(debug)`; the rest of the Stage 3 compatibility surface lives as Prolog
+modules under `src/lib/`.
+
 `source-expansion.js` is the explicit compile-time execution boundary. When an
 already-loaded `term_expansion/2` or `goal_expansion/2` hook exists, program
 preparation invokes it with a fresh bounded `Solver` against the partially built

package/src/CLPZ-MIGRATION.md

@@ -55,17 +55,35 @@ The regression corpus covers clause-list generation, variable-sharing goal
 expansion, qualified hook lexical context, and the Scryer pattern where a
 `term_expansion/2` hook calls `expand_term/2` to generate a DCG predicate.
 
-## What still prevents a drop-in Scryer `clpz.pl`
+## Stage 3: Scryer support-library surface
 
-The remaining compatibility work is the supporting Scryer library surface
-(`assoc`, `pairs`, `between`, `dcgs`, `terms`, `error`, `si`, `freeze`,
-`arithmetic`, `debug`, and `format`) at the interfaces expected by that source,
-plus any small builtin gaps exposed while loading those modules. The generated
-predicates and custom Duo DCG `++>` expansion are no longer VM/compiler
-blockers: Scryer's own `term_expansion/2` can now perform that lowering.
+This stage is implemented. EyeProlog now registers the library names imported by
+Scryer's current `clpz.pl`: `assoc`, `pairs`, `between`, `dcgs`, `terms`,
+`error`, `si`, `freeze`, `arithmetic`, `debug`, and `format`. The implementations
+are deliberately small compatibility layers where CLP(Z) needs only a subset of
+the upstream module, while observable predicate contracts stay at the Prolog
+library boundary. In particular, `library(freeze)` is implemented with the same
+attributed-variable `verify_attributes/3` protocol introduced in Stage 1.
 
-These are reusable library compatibility gaps, not reasons to add more
-CLP(Z)-specific code to `term.js` or `solver.js`.
+Two remaining Scryer runtime facilities are generic rather than constraint
+specific. `Env` now carries a copy-on-write backtrackable blackboard, exposed to
+Prolog through `bb_get/2` and `bb_b_put/2` compatibility wrappers, and
+`library(terms)` provides `copy_term_nat/2` using EyeProlog's attribute-free
+logical copy semantics. Regression coverage exercises the support modules,
+blackboard rollback, attribute-free copying, and the exact import/attribute
+prelude used by upstream CLP(Z).
+
+## What still prevents replacing `src/clpz.js`
+
+The VM/compiler and named support-library blockers are now closed. The remaining
+work is direct upstream-source integration: vendor a pinned Scryer `clpz.pl`,
+apply only the small compatibility patches exposed by loading the complete file,
+and run it side-by-side against EyeProlog's existing CLP(Z) corpus plus selected
+Scryer regressions. Only after behavioral and performance parity should the
+`eyeprolog__clpz_*` adapters and `Env._clpz` store be removed.
+
+This boundary is intentional: Stage 3 does not claim that the complete upstream
+solver is active merely because its dependency prelude loads.
 
 ## Migration rule
 

package/src/lib/arithmetic.pl

@@ -0,0 +1,36 @@
+/** Integer arithmetic helpers used by Scryer's CLP(Z) source. */
+
+:- module(arithmetic, [lsb/2, msb/2, popcount/2]).
+
+:- use_module(library(error), [must_be/2, domain_error/3]).
+
+lsb(X, N) :-
+    must_be(integer, X),
+    ( X < 1 -> domain_error(not_less_than_one, X, lsb/2)
+    ; Low is X /\ (-X), arithmetic__msb(Low, -1, N)
+    ).
+
+msb(X, N) :-
+    must_be(integer, X),
+    ( X < 1 -> domain_error(not_less_than_one, X, msb/2)
+    ; Shifted is X >> 1, arithmetic__msb(Shifted, 0, N)
+    ).
+
+arithmetic__msb(0, N, N) :- !.
+arithmetic__msb(X, N0, N) :-
+    X1 is X >> 1,
+    N1 is N0 + 1,
+    arithmetic__msb(X1, N1, N).
+
+popcount(X, Count) :-
+    must_be(integer, X),
+    ( X < 0 -> domain_error(not_less_than_zero, X, popcount/2)
+    ; arithmetic__popcount(X, 0, Count)
+    ).
+
+arithmetic__popcount(0, Count, Count) :- !.
+arithmetic__popcount(X, Count0, Count) :-
+    Bit is X /\ 1,
+    Count1 is Count0 + Bit,
+    X1 is X >> 1,
+    arithmetic__popcount(X1, Count1, Count).

package/src/lib/assoc.pl

@@ -0,0 +1,42 @@
+/** Minimal Scryer-compatible association maps.
+
+    The public operations used by library(clpz) are represented as a sorted
+    list wrapped in assoc/1.  The representation is intentionally private: the
+    predicates preserve the observable assoc contracts while keeping the
+    compatibility layer small and declarative.
+*/
+
+:- module(assoc, [
+    empty_assoc/1,
+    assoc_to_list/2,
+    get_assoc/3,
+    put_assoc/4
+]).
+
+empty_assoc(assoc([])).
+
+assoc_to_list(assoc(Pairs), Pairs).
+
+get_assoc(Key, assoc(Pairs), Value) :-
+    assoc__get(Pairs, Key, Value).
+
+assoc__get([K-V|Pairs], Key, Value) :-
+    compare(Order, Key, K),
+    assoc__get(Order, Key, Value, V, Pairs).
+
+assoc__get(=, _, Value, Value, _).
+assoc__get(>, Key, Value, _, Pairs) :-
+    assoc__get(Pairs, Key, Value).
+
+put_assoc(Key, assoc(Pairs0), Value, assoc(Pairs)) :-
+    assoc__put(Pairs0, Key, Value, Pairs).
+
+assoc__put([], Key, Value, [Key-Value]).
+assoc__put([K-V|Pairs0], Key, Value, Pairs) :-
+    compare(Order, Key, K),
+    assoc__put(Order, Key, Value, K, V, Pairs0, Pairs).
+
+assoc__put(=, Key, Value, _, _, Pairs, [Key-Value|Pairs]).
+assoc__put(<, Key, Value, K, V, Pairs, [Key-Value,K-V|Pairs]).
+assoc__put(>, Key, Value, K, V, Pairs0, [K-V|Pairs]) :-
+    assoc__put(Pairs0, Key, Value, Pairs).

package/src/lib/between.pl

@@ -0,0 +1,54 @@
+/** Scryer-compatible integer generators needed by CLP(Z). */
+
+:- module(between, [between/3, gen_int/1, gen_nat/1, numlist/2, numlist/3, repeat/1]).
+
+:- use_module(library(error), [must_be/2, can_be/2]).
+
+between(Lower, Upper, X) :-
+    must_be(integer, Lower),
+    must_be(integer, Upper),
+    can_be(integer, X),
+    ( nonvar(X) -> Lower =< X, X =< Upper
+    ; Lower =< Upper, between__from(Lower, Upper, X)
+    ).
+
+between__from(Lower, Upper, Lower).
+between__from(Lower, Upper, X) :-
+    Lower < Upper,
+    Next is Lower + 1,
+    between__from(Next, Upper, X).
+
+gen_nat(N) :-
+    can_be(integer, N),
+    ( var(N) -> between__nats(0, N) ; N >= 0 ).
+
+between__nats(N, N).
+between__nats(N0, N) :- N1 is N0 + 1, between__nats(N1, N).
+
+gen_int(N) :-
+    can_be(integer, N),
+    ( var(N) -> between__ints(0, N) ; true ).
+
+between__ints(0, 0).
+between__ints(I, I) :- I > 0.
+between__ints(I, N) :- I > 0, N is -I.
+between__ints(I0, N) :- I1 is I0 + 1, between__ints(I1, N).
+
+repeat(N) :-
+    must_be(integer, N), N > 0,
+    between__repeat(N).
+between__repeat(_).
+between__repeat(N0) :- N0 > 1, N is N0 - 1, between__repeat(N).
+
+numlist(Upper, List) :- numlist(1, Upper, List).
+
+numlist(Lower, Upper, List) :-
+    must_be(integer, Lower),
+    must_be(integer, Upper),
+    between__numlist(Lower, Upper, List).
+
+between__numlist(Lower, Upper, []) :- Lower > Upper, !.
+between__numlist(Lower, Upper, [Lower|Rest]) :-
+    Lower =< Upper,
+    Next is Lower + 1,
+    between__numlist(Next, Upper, Rest).

package/src/lib/dcgs.pl

@@ -0,0 +1,23 @@
+/** Scryer-compatible DCG helpers.
+
+    EyeProlog already provides phrase/2-3 and ISO-style grammar expansion in the
+    runtime.  This module supplies the sequence combinators used by Scryer's
+    declarative libraries and exports the built-in phrase predicates under the
+    expected module name.
+*/
+
+:- module(dcgs, [
+    phrase/2,
+    phrase/3,
+    seq//1,
+    seqq//1
+]).
+
+seq([]) --> [].
+seq([Element|Elements]) --> [Element], seq(Elements).
+
+seqq([]) --> [].
+seqq([Elements|Sequences]) --> seq(Elements), seqq(Sequences).
+
+'...' --> [].
+'...' --> [_], '...'.

package/src/lib/debug.pl

@@ -0,0 +1,17 @@
+/** Compatibility hooks for Scryer libraries.
+
+    CLP(Z) only needs the backtrackable blackboard operations; the debugging
+    predicates are deliberately harmless no-ops unless EyeProlog grows a debug
+    topic UI later.
+*/
+
+:- module(debug, [debug/1, debug/3, nodebug/1, bb_get/2, bb_b_put/2]).
+
+:- meta_predicate(debug(+, +, +)).
+
+debug(_).
+debug(_, _, _).
+nodebug(_).
+
+bb_get(Key, Value) :- eyeprolog__bb_get(Key, Value).
+bb_b_put(Key, Value) :- eyeprolog__bb_b_put(Key, Value).

package/src/lib/error.pl

@@ -0,0 +1,123 @@
+/** Small Scryer-compatible error/type layer used by reusable libraries. */
+
+:- module(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
+]).
+
+:- meta_predicate(call_with_error_context(0, +)).
+
+must_be(Type, Term) :-
+    ( var(Type) -> instantiation_error(must_be/2)
+    ; error__must_be(Type, Term)
+    ).
+
+error__must_be(integer, Term) :- !,
+    ( var(Term) -> instantiation_error(must_be/2)
+    ; integer(Term) -> true
+    ; type_error(integer, Term, must_be/2)
+    ).
+error__must_be(atom, Term) :- !,
+    ( var(Term) -> instantiation_error(must_be/2)
+    ; atom(Term) -> true
+    ; type_error(atom, Term, must_be/2)
+    ).
+error__must_be(number, Term) :- !,
+    ( var(Term) -> instantiation_error(must_be/2)
+    ; number(Term) -> true
+    ; type_error(number, Term, must_be/2)
+    ).
+error__must_be(var, Term) :- !,
+    ( var(Term) -> true
+    ; throw(error(uninstantiation_error(Term), must_be/2))
+    ).
+error__must_be(ground, Term) :- !,
+    ( ground(Term) -> true ; instantiation_error(must_be/2) ).
+error__must_be(acyclic, Term) :- !,
+    ( acyclic_term(Term) -> true ; type_error(acyclic_term, Term, must_be/2) ).
+error__must_be(list, Term) :- !,
+    error__proper_list(Term).
+error__must_be(list(Type), Term) :- !,
+    error__proper_list_of(Term, Type).
+error__must_be(pair, Term) :- !,
+    ( var(Term) -> instantiation_error(must_be/2)
+    ; Term = _-_ -> true
+    ; type_error(pair, Term, must_be/2)
+    ).
+error__must_be(not_less_than_zero, Term) :- !,
+    must_be(integer, Term),
+    ( Term >= 0 -> true ; domain_error(not_less_than_zero, Term, must_be/2) ).
+error__must_be(Type, Term) :-
+    ( var(Term) -> instantiation_error(must_be/2)
+    ; type_error(Type, Term, must_be/2)
+    ).
+
+error__proper_list([]).
+error__proper_list([_|Tail]) :- !, error__proper_list(Tail).
+error__proper_list(Term) :-
+    ( var(Term) -> instantiation_error(must_be/2)
+    ; type_error(list, Term, must_be/2)
+    ).
+
+error__proper_list_of([], _).
+error__proper_list_of([Head|Tail], Type) :- !,
+    must_be(Type, Head),
+    error__proper_list_of(Tail, Type).
+error__proper_list_of(Term, _) :-
+    ( var(Term) -> instantiation_error(must_be/2)
+    ; type_error(list, Term, must_be/2)
+    ).
+
+can_be(Type, Term) :-
+    ( var(Type) -> instantiation_error(can_be/2)
+    ; var(Term) -> true
+    ; error__can_be(Type, Term)
+    ).
+
+error__can_be(integer, Term) :- !,
+    ( integer(Term) -> true ; type_error(integer, Term, can_be/2) ).
+error__can_be(atom, Term) :- !,
+    ( atom(Term) -> true ; type_error(atom, Term, can_be/2) ).
+error__can_be(number, Term) :- !,
+    ( number(Term) -> true ; type_error(number, Term, can_be/2) ).
+error__can_be(list, Term) :- !, error__partial_list(Term).
+error__can_be(list(Type), Term) :- !, error__partial_list_of(Term, Type).
+error__can_be(not_less_than_zero, Term) :- !,
+    ( integer(Term) ->
+        ( Term >= 0 -> true ; domain_error(not_less_than_zero, Term, can_be/2) )
+    ; type_error(integer, Term, can_be/2)
+    ).
+error__can_be(Type, Term) :- error__must_be(Type, Term).
+
+error__partial_list(Term) :- var(Term), !.
+error__partial_list([]) :- !.
+error__partial_list([_|Tail]) :- !, error__partial_list(Tail).
+error__partial_list(Term) :- type_error(list, Term, can_be/2).
+
+error__partial_list_of(Term, _) :- var(Term), !.
+error__partial_list_of([], _) :- !.
+error__partial_list_of([Head|Tail], Type) :- !,
+    can_be(Type, Head),
+    error__partial_list_of(Tail, Type).
+error__partial_list_of(Term, _) :- type_error(list, Term, can_be/2).
+
+instantiation_error :- throw(error(instantiation_error, [])).
+instantiation_error(Context) :- throw(error(instantiation_error, Context)).
+domain_error(Type, Term) :- throw(error(domain_error(Type, Term), [])).
+domain_error(Type, Term, Context) :- throw(error(domain_error(Type, Term), Context)).
+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), [])).
+
+call_with_error_context(Goal, Pair) :-
+    catch(Goal, error(Error, Context), throw(error(Error, [Pair|Context]))).

package/src/lib/format.pl

@@ -0,0 +1,35 @@
+/** Small format/2 compatibility layer covering the controls used by CLP(Z). */
+
+:- module(format, [format/2]).
+
+format(Template, Arguments) :-
+    format__chars(Template, Chars),
+    format__emit(Chars, Arguments).
+
+format__chars(Template, Chars) :-
+    atom(Template), !,
+    atom_chars(Template, Chars).
+format__chars(Chars, Chars).
+
+format__emit([], []).
+format__emit(['~','~'|Chars], Args) :- !,
+    put_char('~'),
+    format__emit(Chars, Args).
+format__emit(['~',n|Chars], Args) :- !,
+    nl,
+    format__emit(Chars, Args).
+format__emit(['~',w|Chars], [Arg|Args]) :- !,
+    write(Arg),
+    format__emit(Chars, Args).
+format__emit(['~',q|Chars], [Arg|Args]) :- !,
+    writeq(Arg),
+    format__emit(Chars, Args).
+format__emit(['~',a|Chars], [Arg|Args]) :- !,
+    write(Arg),
+    format__emit(Chars, Args).
+format__emit(['~',d|Chars], [Arg|Args]) :- !,
+    write(Arg),
+    format__emit(Chars, Args).
+format__emit([Char|Chars], Args) :-
+    put_char(Char),
+    format__emit(Chars, Args).

package/src/lib/freeze.pl

@@ -0,0 +1,28 @@
+/** Attributed-variable implementation of Scryer-compatible freeze/2. */
+
+:- module(freeze, [freeze/2]).
+
+:- use_module(library(atts)).
+:- meta_predicate(freeze(-, 0)).
+:- attribute frozen/1.
+
+verify_attributes(Var, Other, Goals) :-
+    get_atts(Var, frozen(FrozenA)), !,
+    ( var(Other) ->
+        ( get_atts(Other, frozen(FrozenB)) ->
+            put_atts(Other, frozen((FrozenB,FrozenA)))
+        ; put_atts(Other, frozen(FrozenA))
+        ),
+        Goals = []
+    ; Goals = [FrozenA]
+    ).
+verify_attributes(_, _, []).
+
+freeze(X, Goal) :-
+    put_atts(Fresh, frozen(Goal)),
+    Fresh = X.
+
+attribute_goals(Var) -->
+    { get_atts(Var, frozen(Goals)),
+      put_atts(Var, -frozen(_)) },
+    [freeze:freeze(Var, Goals)].

package/src/lib/pairs.pl

@@ -0,0 +1,36 @@
+/** Scryer-compatible pair helpers used by CLP(Z). */
+
+:- module(pairs, [
+    pairs_keys_values/3,
+    pairs_keys/2,
+    pairs_values/2,
+    group_pairs_by_key/2,
+    map_list_to_pairs/3
+]).
+
+:- meta_predicate(map_list_to_pairs(2, ?, ?)).
+
+pairs_keys_values([], [], []).
+pairs_keys_values([A-B|ABs], [A|As], [B|Bs]) :-
+    pairs_keys_values(ABs, As, Bs).
+
+pairs_keys(Pairs, Keys) :- pairs_keys_values(Pairs, Keys, _).
+pairs_values(Pairs, Values) :- pairs_keys_values(Pairs, _, Values).
+
+map_list_to_pairs(Pred, List, Pairs) :-
+    pairs__map_list_to_pairs(List, Pred, Pairs).
+
+pairs__map_list_to_pairs([], _, []).
+pairs__map_list_to_pairs([Head|Tail0], Pred, [Key-Head|Tail]) :-
+    call(Pred, Head, Key),
+    pairs__map_list_to_pairs(Tail0, Pred, Tail).
+
+group_pairs_by_key([], []).
+group_pairs_by_key([K-V|Pairs0], [K-[V|Values]|Pairs]) :-
+    pairs__same_key(K, Pairs0, Values, Pairs1),
+    group_pairs_by_key(Pairs1, Pairs).
+
+pairs__same_key(K0, [K1-V|Pairs0], [V|Values], Pairs) :-
+    K0 == K1, !,
+    pairs__same_key(K0, Pairs0, Values, Pairs).
+pairs__same_key(_, Pairs, [], Pairs).

package/src/lib/si.pl

@@ -0,0 +1,62 @@
+/** Sufficient-instantiation tests compatible with Scryer library(si). */
+
+:- module(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
+]).
+
+:- meta_predicate(not_si(0)).
+:- meta_predicate(when_si(+, 0)).
+
+atom_si(A) :- ( var(A) -> throw(error(instantiation_error, atom_si/1)) ; atom(A) ).
+integer_si(I) :- ( var(I) -> throw(error(instantiation_error, integer_si/1)) ; integer(I) ).
+atomic_si(A) :- ( var(A) -> throw(error(instantiation_error, atomic_si/1)) ; atomic(A) ).
+
+list_si(List) :- si__list(List).
+si__list([]).
+si__list([_|Tail]) :- !, si__list(Tail).
+si__list(Term) :-
+    ( var(Term) -> throw(error(instantiation_error, list_si/1)) ; fail ).
+
+character_si(C) :-
+    ( var(C) -> throw(error(instantiation_error, character_si/1))
+    ; atom(C), atom_length(C, 1)
+    ).
+
+term_si(Term) :-
+    ( ground(Term) -> acyclic_term(Term)
+    ; throw(error(instantiation_error, term_si/1))
+    ).
+
+chars_si(Chars) :-
+    list_si(Chars),
+    si__chars(Chars).
+si__chars([]).
+si__chars([C|Cs]) :- character_si(C), si__chars(Cs).
+
+dif_si(X, Y) :-
+    X \== Y,
+    ( X \= Y -> true ; throw(error(instantiation_error, dif_si/2)) ).
+
+not_si(Goal) :- term_si(Goal), \+ Goal.
+
+when_si(Condition, Goal) :-
+    ( si__condition(Condition) ->
+        ( call(Condition) -> call(Goal)
+        ; throw(error(instantiation_error, when_si/2)) )
+    ; throw(error(domain_error(when_condition_si, Condition), when_si/2))
+    ).
+
+si__condition(Condition) :- var(Condition), !, throw(error(instantiation_error, when_si/2)).
+si__condition(ground(_)).
+si__condition(nonvar(_)).
+si__condition((A,B)) :- si__condition(A), si__condition(B).
+si__condition((A;B)) :- si__condition(A), si__condition(B).

package/src/lib/terms.pl

@@ -0,0 +1,18 @@
+/** Term helpers compatible with the Scryer library surface used by CLP(Z). */
+
+:- module(terms, [numbervars/3, copy_term_nat/2]).
+
+:- use_module(library(error), [must_be/2, can_be/2]).
+
+copy_term_nat(Term, Copy) :- copy_term(Term, Copy).
+
+numbervars(Term, N0, N) :-
+    must_be(integer, N0),
+    can_be(integer, N),
+    term_variables(Term, Variables),
+    terms__numbervars(Variables, N0, N).
+
+terms__numbervars([], N, N).
+terms__numbervars(['$VAR'(N0)|Variables], N0, N) :-
+    N1 is N0 + 1,
+    terms__numbervars(Variables, N1, N).

package/src/scryer-compat.js

@@ -0,0 +1,39 @@
+// Small host primitives needed by Scryer-style declarative libraries.
+//
+// Keep these facilities generic: they are not part of the CLP(Z) engine. The
+// backtrackable blackboard lives in Env so ordinary Prolog choice points undo
+// writes automatically.
+
+import { ATOM, NUMBER, STRING, deref, unify } from './term.js';
+import { PrologError } from './errors.js';
+
+function blackboardKey(term, env) {
+  const value = deref(term, env);
+  if (value.type === ATOM) return `a:${value.name}`;
+  if (value.type === NUMBER) return `n:${value.name}`;
+  if (value.type === STRING) return `s:${value.name}`;
+  if (value.type === 'var') throw new PrologError('instantiation_error');
+  throw new PrologError('type_error(atomic)', value);
+}
+
+function* bbGetBuiltin({ goal, env }) {
+  const key = blackboardKey(goal.args[0], env);
+  const stored = env.getBacktrackableBlackboard(key);
+  if (stored === undefined) return;
+  const next = env.clone();
+  if (unify(goal.args[1], stored, next)) yield next;
+}
+
+function* bbPutBuiltin({ goal, env }) {
+  const next = env.clone();
+  const key = blackboardKey(goal.args[0], next);
+  next.putBacktrackableBlackboard(key, deref(goal.args[1], 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 });
+  },
+};

package/src/standard-library.js

@@ -6,23 +6,35 @@ import { PrologError, createDefaultRegistry, eyePrologLibraryBuiltins } from './
 import { clpzBuiltins } from './clpz.js';
 import { attsBuiltins } from './atts.js';
 import { expansionBuiltins } from './expansion-builtins.js';
+import { scryerCompatibilityBuiltins } from './scryer-compat.js';
 import { registerCleanupBuiltins } from './cleanup.js';
 import { fs, isNode, memoryStatistics } from './platform.js';
 import { ATOM, VAR, atom, deref, numberTerm, unify } from './term.js';
 
 const moduleFiles = Object.freeze({
   aggregate: 'aggregate.pl',
+  arithmetic: 'arithmetic.pl',
+  assoc: 'assoc.pl',
   atts: 'atts.pl',
+  between: 'between.pl',
   clpz: 'clpz.pl',
   comparison: 'comparison.pl',
   dates: 'dates.pl',
+  dcgs: 'dcgs.pl',
+  debug: 'debug.pl',
+  error: 'error.pl',
+  format: 'format.pl',
+  freeze: 'freeze.pl',
   iso_ext: 'iso_ext.pl',
   lambda: 'lambda.pl',
   lists: 'lists.pl',
+  pairs: 'pairs.pl',
   primes: 'primes.pl',
   prologue: 'prologue.pl',
   random: 'random.pl',
+  si: 'si.pl',
   strings: 'strings.pl',
+  terms: 'terms.pl',
   uuid: 'uuid.pl',
 });
 
@@ -190,6 +202,7 @@ export function createEyePrologRegistry() {
   eyePrologLibraryBuiltins.register(registry);
   attsBuiltins.register(registry);
   expansionBuiltins.register(registry);
+  scryerCompatibilityBuiltins.register(registry);
   clpzBuiltins.register(registry);
   registry.eyePrologLibrary = true;
   return registry;

package/src/term.js

@@ -109,6 +109,9 @@ export class Env {
     this._prologAttributes = null;
     this._attributeHookRunner = null;
     this._pendingAttributeGoals = null;
+    // Backtrackable blackboard entries used by Scryer-compatible libraries.
+    // Values are logical terms and the map is copy-on-write across Env clones.
+    this._backtrackableBlackboard = null;
     this._clpz = null;
     this._occursCheckHandler = null;
     this._localVariables = null;
@@ -127,6 +130,7 @@ export class Env {
     clone._prologAttributes = this._prologAttributes;
     clone._attributeHookRunner = this._attributeHookRunner;
     clone._pendingAttributeGoals = this._pendingAttributeGoals;
+    clone._backtrackableBlackboard = this._backtrackableBlackboard;
     clone._clpz = this._clpz;
     clone._occursCheckHandler = this._occursCheckHandler;
     clone._localVariables = this._localVariables;
@@ -148,12 +152,21 @@ export class Env {
     this._variableAnnotations = other._variableAnnotations;
     this._prologAttributes = other._prologAttributes;
     this._pendingAttributeGoals = other._pendingAttributeGoals;
+    this._backtrackableBlackboard = other._backtrackableBlackboard;
     this._clpz = other._clpz;
     // Execution callbacks belong to the Solver driving this Env, not to the
     // logical branch being adopted from an inner attribute-hook call.
     this._localVariables = other._localVariables;
     return this;
   }
+  getBacktrackableBlackboard(key) {
+    return this._backtrackableBlackboard?.get(key);
+  }
+  putBacktrackableBlackboard(key, value) {
+    const next = new Map(this._backtrackableBlackboard ?? []);
+    next.set(key, value);
+    this._backtrackableBlackboard = next;
+  }
   hasLocalVariables() {
     return this._localVariables != null && this._localVariables.size !== 0;
   }

package/test/run-regression.mjs

@@ -229,6 +229,77 @@ check :- old(X), X = ok.
           'a user hook defined by a library module executes in its lexical module');
       },
     },
+    {
+      name: 'Scryer CLP(Z) support libraries provide the dependency surface',
+      run: () => {
+        const source = `:- module(scryer_support, [snapshot/6, blackboard_rollback/1, copy_drops_attrs/0]).
+:- use_module(library(assoc)).
+:- use_module(library(pairs)).
+:- use_module(library(between)).
+:- use_module(library(dcgs)).
+:- use_module(library(terms)).
+:- use_module(library(error)).
+:- use_module(library(si)).
+:- use_module(library(freeze)).
+:- use_module(library(arithmetic)).
+:- use_module(library(debug)).
+:- use_module(library(format)).
+:- use_module(library(atts)).
+snapshot(Pairs, Keys, Values, Ns, Bits, Wake) :-
+    empty_assoc(A0),
+    put_assoc(2, A0, b, A1),
+    put_assoc(1, A1, a, A2),
+    assoc_to_list(A2, Pairs),
+    pairs_keys_values(Pairs, Keys, Values),
+    numlist(1, 3, Ns),
+    list_si(Ns),
+    arithmetic:popcount(13, Bits),
+    freeze(X, Wake = awake),
+    X = go.
+blackboard_rollback(Value) :-
+    bb_b_put(k, base),
+    ( bb_b_put(k, temporary), fail ; bb_get(k, Value) ).
+copy_drops_attrs :-
+    put_attr(X, probe, value),
+    copy_term_nat(X, Copy),
+    term_attributed_variables(Copy, []).
+`;
+        const snapshot = run(source, { goal: 'scryer_support:snapshot(Pairs,Keys,Values,Ns,Bits,Wake)' });
+        assertIncludes(snapshot.stdout,
+          'scryer_support:snapshot([1 - a, 2 - b], [1, 2], "ab", [1, 2, 3], 3, awake).',
+          'assoc, pairs, between, si, freeze, and arithmetic compatibility');
+        assertIncludes(run(source, { goal: 'scryer_support:blackboard_rollback(V)' }).stdout,
+          'scryer_support:blackboard_rollback(base).',
+          'backtrackable blackboard writes roll back with Env branches');
+        assertIncludes(run(source, { goal: 'scryer_support:copy_drops_attrs' }).stdout,
+          'scryer_support:copy_drops_attrs.',
+          'copy_term_nat/2 omits attributed-variable state');
+        assertEqual(run(source, { goal: 'debug:bb_get(missing,_V)' }).stats.completed_goal_lists, 0,
+          'bb_get/2 is semidet for an absent key');
+        const prelude = `:- module(scryer_clpz_prelude, [probe/0]).
+:- use_module(library(assoc)).
+:- use_module(library(pairs)).
+:- use_module(library(between)).
+:- use_module(library(lists)).
+:- use_module(library(atts)).
+:- use_module(library(iso_ext)).
+:- use_module(library(dcgs)).
+:- use_module(library(terms)).
+:- use_module(library(error), [domain_error/3, type_error/3, can_be/2]).
+:- use_module(library(si)).
+:- use_module(library(freeze)).
+:- use_module(library(arithmetic)).
+:- use_module(library(debug)).
+:- use_module(library(format)).
+:- attribute clpz/1, clpz_aux/1, clpz_relation/1, edges/1, flow/1,
+             parent/1, free/1, queue/2, disabled/0.
+probe :- empty_assoc(A), copy_term_nat(A, _), bb_b_put(current, ok), bb_get(current, ok).
+`;
+        assertIncludes(run(prelude, { goal: 'scryer_clpz_prelude:probe' }).stdout,
+          'scryer_clpz_prelude:probe.',
+          'the dependency and attribute prelude used by upstream clpz.pl loads unchanged');
+      },
+    },
     {
       name: 'write_term variable_names/1 errors preserve the instantiated option culprit (issue #69)',
       run: () => {
@@ -4829,7 +4900,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, 173, 'EyeProlog registry contains ISO definitions, cleanup controls, observability extensions, WFS tnot/1, and private library adapters');
+        assertEqual(library.defs.size, 175, 'EyeProlog registry contains ISO definitions, cleanup controls, observability extensions, WFS tnot/1, and private library adapters');
         assertEqual(Boolean(registry.get('phrase', 2)), true, 'Part 3 phrase/2 exists');
         assertEqual(Boolean(registry.get('phrase', 3)), true, 'Part 3 phrase/3 exists');
         assertEqual(registry.get('statistics', 0), null, 'statistics/0 is absent from the ISO registry');
@@ -4872,6 +4943,8 @@ answer(ok) :-
         assertEqual(registry.get('put_atts', 2), null, 'put_atts/2 is absent from the ISO registry');
         assertEqual(Boolean(library.get('put_atts', 2)), true, 'put_atts/2 is registered for attributed-variable libraries');
         assertEqual(Boolean(library.get('$put_to_attr_list', 3)), true, 'private attribute-list adapter is registered');
+        assertEqual(Boolean(library.get('eyeprolog__bb_get', 2)), true, 'private backtrackable blackboard reader is registered');
+        assertEqual(Boolean(library.get('eyeprolog__bb_b_put', 2)), true, 'private backtrackable blackboard writer is registered');
         assertEqual(library.get('between', 3), null, 'between/3 remains portable Prolog');
         assertEqual(library.get('smallest_divisor_from', 3), null, 'smallest_divisor_from/3 remains portable Prolog');
         assertEqual(library.get('random', 3), null, 'random/3 remains portable Prolog');

package/the-art-of-eyeprolog.md

@@ -6427,9 +6427,12 @@ is intended to support staged reuse of Markus Triska's MIT-licensed
 The generic compile-time expansion blocker is now closed: normal-profile source
 loading runs module-local and `user` `term_expansion/2` and `goal_expansion/2`
 hooks, accepts clause-list expansions, preserves surrounding variable sharing,
-and provides `expand_term/2` for processor DCG lowering. This is sufficient for
-Scryer's generated-predicate and Duo-DCG expansion strategy. The remaining
-blocker is the supporting Scryer library surface used by that source; the
+and provides `expand_term/2` for processor DCG lowering. EyeProlog now also
+registers the Scryer support modules needed by that source (`assoc`, `pairs`,
+`between`, `dcgs`, `terms`, `error`, `si`, `freeze`, `arithmetic`, `debug`, and
+`format`) and supplies a generic copy-on-write backtrackable blackboard. The
+remaining migration step is to vendor and load a pinned upstream `clpz.pl`, then
+establish behavioral and performance parity before removing the JS kernel. The
 migration state is tracked in [`src/CLPZ-MIGRATION.md`](src/CLPZ-MIGRATION.md).
 Until parity is reached, the JS kernel remains the active implementation so
 existing CLP(Z) behavior does not regress.