eyeprolog 1.5.1 → 1.5.3

package/README.md

@@ -31,8 +31,6 @@ Run EyeProlog without installing it globally:
 
 ```sh
 npx --yes eyeprolog
-?- use_module(library(lists)).
-   true.
 ?- member(X, [prolog, logic]).
    X = prolog
 ;  X = logic.
@@ -63,7 +61,9 @@ printf 'human(socrates).\nmortal(X) :- human(X).\n' |
 Normal mode executes top-level `Conclusion :+ Premise` rules natively when no explicit
 `-g/--goal` is supplied. `true :+ Goal` prints answers and `false :+ Goal` emits a
 `fuse/1`; JavaScript `run()` follows the same rule. Strict ISO mode disables this
-extension. See [*The Art of EyeProlog*](the-art-of-eyeprolog.md) for the full semantics.
+extension. 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.
 
 ## Links
 

package/index.d.ts

@@ -289,6 +289,9 @@ export const eyePrologLibraryIndicators: readonly string[];
 export const eyePrologNativeLibraryIndicators: readonly string[];
 export const eyePrologPortableLibraryIndicators: readonly string[];
 export const eyePrologInteropAutoload: Readonly<Record<string, string>>;
+export const eyePrologLibraryAutoload: Readonly<Record<string, string>>;
+export const eyePrologAmbiguousLibraryAutoload: Readonly<Record<string, readonly string[]>>;
+export const eyePrologLibraryAutoloadModules: readonly string[];
 export const eyePrologInteropLibraryIndicators: readonly string[];
 export const eyePrologInteropLibraryModules: readonly string[];
 export class PrologError extends Error {
@@ -374,6 +377,9 @@ declare const eyeprolog: {
   eyePrologNativeLibraryIndicators: typeof eyePrologNativeLibraryIndicators;
   eyePrologPortableLibraryIndicators: typeof eyePrologPortableLibraryIndicators;
   eyePrologInteropAutoload: typeof eyePrologInteropAutoload;
+  eyePrologLibraryAutoload: typeof eyePrologLibraryAutoload;
+  eyePrologAmbiguousLibraryAutoload: typeof eyePrologAmbiguousLibraryAutoload;
+  eyePrologLibraryAutoloadModules: typeof eyePrologLibraryAutoloadModules;
   eyePrologInteropLibraryIndicators: typeof eyePrologInteropLibraryIndicators;
   eyePrologInteropLibraryModules: typeof eyePrologInteropLibraryModules;
   run: typeof run;

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.5.1",
+  "version": "1.5.3",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",
@@ -46,7 +46,8 @@
   },
   "scripts": {
     "test": "node test/run-all.mjs",
-    "generate": "node tools/extract-book-examples.mjs",
+    "generate": "node tools/generate-library-autoload-index.mjs && node tools/extract-book-examples.mjs",
+    "generate:autoload": "node tools/generate-library-autoload-index.mjs",
     "test:eyeprolog": "node test/run-all.mjs",
     "test:conformance": "node test/run-conformance.mjs",
     "test:iso-strict": "node test/run-iso-strict.mjs",

package/src/cli.js

@@ -281,7 +281,7 @@ Options:
   --iso-strict          Use ISO/IEC 13211-1 core + Corrigenda 1-3 only;
                         reject EyeProlog language extensions.
   --portable            Enforce the EyeProlog/Trealla/Scryer interop profile.
-  --no-autoload         Disable conservative interop predicate autoloading.
+  --no-autoload         Disable bundled library predicate autoloading.
   -v, --version         Show the package version and exit.
   -w, --warnings        Print non-fatal portability warnings to stderr.
   -g, --goal goal       Solve goal and print its ground answers; may be repeated.

package/src/index.js

@@ -21,6 +21,9 @@ export {
   eyePrologNativeLibraryIndicators,
   eyePrologPortableLibraryIndicators,
   eyePrologInteropAutoload,
+  eyePrologLibraryAutoload,
+  eyePrologAmbiguousLibraryAutoload,
+  eyePrologLibraryAutoloadModules,
   eyePrologInteropLibraryIndicators,
   eyePrologInteropLibraryModules,
 } from './standard-library.js';

package/src/library-autoload-index.js

@@ -0,0 +1,346 @@
+// Generated by tools/generate-library-autoload-index.mjs.
+// Do not edit by hand; module/2 export lists under src/lib/ are the source of truth.
+
+export const eyePrologLibraryAutoload = Object.freeze({
+  ",/3": "reif",
+  ";/3": "reif",
+  ".../2": "iso_ext",
+  "*/1": "debug",
+  "\\/1": "lambda",
+  "\\/2": "lambda",
+  "\\/3": "lambda",
+  "\\/4": "lambda",
+  "\\/5": "lambda",
+  "\\/6": "lambda",
+  "\\/7": "lambda",
+  "\\/8": "lambda",
+  "#/\\/2": "clpz",
+  "#\\//2": "clpz",
+  "#\\/1": "clpz",
+  "#\\/2": "clpz",
+  "#\\=/2": "clpz",
+  "#</2": "clpz",
+  "#</3": "clpz",
+  "#<==/2": "clpz",
+  "#<==>/2": "clpz",
+  "#=/2": "clpz",
+  "#=/3": "clpz",
+  "#=</2": "clpz",
+  "#==>/2": "clpz",
+  "#>/2": "clpz",
+  "#>=/2": "clpz",
+  "^/10": "lambda",
+  "^/3": "lambda",
+  "^/4": "lambda",
+  "^/5": "lambda",
+  "^/6": "lambda",
+  "^/7": "lambda",
+  "^/8": "lambda",
+  "^/9": "lambda",
+  "+\\/2": "lambda",
+  "+\\/3": "lambda",
+  "+\\/4": "lambda",
+  "+\\/5": "lambda",
+  "+\\/6": "lambda",
+  "+\\/7": "lambda",
+  "+\\/8": "lambda",
+  "+\\/9": "lambda",
+  "=/3": "reif",
+  "$-/1": "debug",
+  "$/1": "debug",
+  "abolish_all_tables/0": "tabling",
+  "add_edges/3": "ugraphs",
+  "add_vertices/3": "ugraphs",
+  "aggregate_max/5": "aggregate",
+  "aggregate_min/5": "aggregate",
+  "all_different/1": "clpz",
+  "all_distinct/1": "clpz",
+  "append/2": "lists",
+  "append/3": "lists",
+  "assoc_to_keys/2": "assoc",
+  "assoc_to_list/2": "assoc",
+  "assoc_to_values/2": "assoc",
+  "atom_si/1": "si",
+  "atom_string/2": "strings",
+  "atomic_si/1": "si",
+  "automaton/3": "clpz",
+  "automaton/8": "clpz",
+  "bb_b_put/2": "debug",
+  "bb_get/2": "debug",
+  "bb_global_get/2": "debug",
+  "bb_put/2": "debug",
+  "between/3": "between",
+  "call_nth/2": "iso_ext",
+  "call_residue_vars/2": "atts",
+  "call_with_error_context/2": "error",
+  "can_be/2": "error",
+  "cfor/3": "iso_ext",
+  "chain/2": "clpz",
+  "char_type/2": "charsio",
+  "character_si/1": "si",
+  "chars_si/1": "si",
+  "circuit/1": "clpz",
+  "clpz_t/2": "clpz",
+  "complement/2": "ugraphs",
+  "compose/3": "ugraphs",
+  "cond_t/3": "reif",
+  "connect_ugraph/3": "ugraphs",
+  "contains/2": "strings",
+  "copy_term_nat/2": "terms",
+  "countall/2": "iso_ext",
+  "cumulative/1": "clpz",
+  "cumulative/2": "clpz",
+  "current_time/1": "time",
+  "debug/1": "debug",
+  "debug/3": "debug",
+  "del_assoc/4": "assoc",
+  "del_attr/2": "atts",
+  "del_edges/3": "ugraphs",
+  "del_max_assoc/4": "assoc",
+  "del_min_assoc/4": "assoc",
+  "del_vertices/3": "ugraphs",
+  "dif_si/2": "si",
+  "dif/2": "dif",
+  "dif/3": "reif",
+  "difference/3": "dates",
+  "disjoint2/1": "clpz",
+  "domain_error/2": "error",
+  "domain_error/3": "error",
+  "drop/3": "lists",
+  "edges/2": "ugraphs",
+  "element/3": "clpz",
+  "empty_assoc/1": "assoc",
+  "fd_dom/2": "clpz",
+  "fd_inf/2": "clpz",
+  "fd_size/2": "clpz",
+  "fd_sup/2": "clpz",
+  "fd_var/1": "clpz",
+  "findall/4": "iso_ext",
+  "foldl/4": "lists",
+  "foldl/5": "lists",
+  "foldl/6": "lists",
+  "forall/2": "iso_ext",
+  "format_/4": "format",
+  "format_time/4": "time",
+  "format/2": "format",
+  "format/3": "format",
+  "freeze/2": "freeze",
+  "ge/2": "comparison",
+  "gen_assoc/3": "assoc",
+  "gen_int/1": "between",
+  "gen_nat/1": "between",
+  "gensym/2": "gensym",
+  "get_assoc/3": "assoc",
+  "get_assoc/5": "assoc",
+  "get_attr/3": "atts",
+  "get_atts/2": "atts",
+  "get_line_to_chars/3": "charsio",
+  "get_n_chars/3": "charsio",
+  "get_single_char/1": "charsio",
+  "global_cardinality/2": "clpz",
+  "global_cardinality/3": "clpz",
+  "group_pairs_by_key/2": "pairs",
+  "gt/2": "comparison",
+  "if_/3": "reif",
+  "in/2": "clpz",
+  "indomain/1": "clpz",
+  "ins/2": "clpz",
+  "instantiation_error/0": "error",
+  "instantiation_error/1": "error",
+  "integer_si/1": "si",
+  "is_assoc/1": "assoc",
+  "is_ordset/1": "ordsets",
+  "join/3": "strings",
+  "label/1": "clpz",
+  "labeling/1": "clpb",
+  "labeling/2": "clpz",
+  "last/2": "lists",
+  "le/2": "comparison",
+  "length/2": "lists",
+  "lex_chain/1": "clpz",
+  "list_max/2": "lists",
+  "list_min/2": "lists",
+  "list_si/1": "si",
+  "list_to_assoc/2": "assoc",
+  "list_to_ord_set/2": "ordsets",
+  "list_to_set/2": "lists",
+  "listing/1": "format",
+  "lowercase/2": "strings",
+  "lsb/2": "arithmetic",
+  "lt/2": "comparison",
+  "map_assoc/2": "assoc",
+  "map_assoc/3": "assoc",
+  "map_list_to_pairs/3": "pairs",
+  "maplist/2": "lists",
+  "maplist/3": "lists",
+  "maplist/4": "lists",
+  "maplist/5": "lists",
+  "maplist/6": "lists",
+  "maplist/7": "lists",
+  "maplist/8": "lists",
+  "matches/2": "strings",
+  "matches/3": "strings",
+  "max_assoc/3": "assoc",
+  "max_list/2": "lists",
+  "maybe/0": "random",
+  "member/2": "lists",
+  "memberchk/2": "lists",
+  "memberd_t/3": "reif",
+  "min_assoc/3": "assoc",
+  "min_list/2": "lists",
+  "msb/2": "arithmetic",
+  "must_be/2": "error",
+  "neighbors/3": "ugraphs",
+  "neighbours/3": "ugraphs",
+  "nodebug/1": "debug",
+  "not_si/1": "si",
+  "nth0/3": "lists",
+  "nth0/4": "lists",
+  "nth1/3": "lists",
+  "nth1/4": "lists",
+  "number_string/2": "strings",
+  "numbervars/3": "terms",
+  "numlist/2": "between",
+  "numlist/3": "between",
+  "nvalue/2": "clpz",
+  "ord_add_element/3": "ordsets",
+  "ord_del_element/3": "ordsets",
+  "ord_disjoint/2": "ordsets",
+  "ord_empty/1": "ordsets",
+  "ord_intersect/2": "ordsets",
+  "ord_intersect/3": "ordsets",
+  "ord_intersection/2": "ordsets",
+  "ord_intersection/3": "ordsets",
+  "ord_intersection/4": "ordsets",
+  "ord_list_to_assoc/2": "assoc",
+  "ord_memberchk/2": "ordsets",
+  "ord_selectchk/3": "ordsets",
+  "ord_seteq/2": "ordsets",
+  "ord_subset/2": "ordsets",
+  "ord_subtract/3": "ordsets",
+  "ord_symdiff/3": "ordsets",
+  "ord_union/2": "ordsets",
+  "ord_union/3": "ordsets",
+  "ord_union/4": "ordsets",
+  "pairs_keys_values/3": "pairs",
+  "pairs_keys/2": "pairs",
+  "pairs_values/2": "pairs",
+  "permutation/2": "lists",
+  "phrase_from_file/2": "pio",
+  "phrase_from_file/3": "pio",
+  "phrase_to_file/2": "pio",
+  "phrase_to_file/3": "pio",
+  "phrase_to_stream/2": "pio",
+  "phrase/2": "dcgs",
+  "phrase/3": "dcgs",
+  "popcount/2": "arithmetic",
+  "portray_clause_/3": "format",
+  "portray_clause/1": "format",
+  "portray_clause/2": "format",
+  "put_assoc/4": "assoc",
+  "put_attr/3": "atts",
+  "put_atts/2": "atts",
+  "random_integer/3": "random",
+  "random_labeling/2": "clpb",
+  "random/1": "random",
+  "random/3": "random",
+  "reachable/3": "ugraphs",
+  "repeat/1": "between",
+  "replace/4": "strings",
+  "representation_error/1": "error",
+  "reset_gensym/1": "gensym",
+  "resource_error/1": "error",
+  "reverse/2": "lists",
+  "same_length/2": "lists",
+  "sat_count/2": "clpb",
+  "sat/1": "clpb",
+  "scalar_product/4": "clpz",
+  "select/3": "lists",
+  "seq/3": "dcgs",
+  "seqq/3": "dcgs",
+  "serialized/2": "clpz",
+  "set_nth0/4": "lists",
+  "set_random/1": "random",
+  "slice/4": "lists",
+  "smallest_divisor_from/3": "primes",
+  "split/3": "strings",
+  "start_tabling/2": "tabling",
+  "string_concat/3": "strings",
+  "substring/4": "strings",
+  "succ/2": "iso_ext",
+  "sum_list/2": "lists",
+  "sum/3": "clpz",
+  "sumall/3": "aggregate",
+  "take/3": "lists",
+  "taut/2": "clpb",
+  "term_attributed_variables/2": "atts",
+  "term_si/1": "si",
+  "term_string/2": "strings",
+  "tfilter/3": "reif",
+  "time/1": "iso_ext",
+  "tmember_t/3": "reif",
+  "tmember/2": "reif",
+  "top_sort/2": "ugraphs",
+  "top_sort/3": "ugraphs",
+  "tpartition/4": "reif",
+  "transitive_closure/2": "ugraphs",
+  "transpose_ugraph/2": "ugraphs",
+  "transpose/2": "lists",
+  "trim/2": "strings",
+  "tuples_in/2": "clpz",
+  "type_error/2": "error",
+  "type_error/3": "error",
+  "ugraph_union/3": "ugraphs",
+  "uppercase/2": "strings",
+  "uuid_string/2": "uuid",
+  "uuid/3": "uuid",
+  "uuidv4_string/1": "uuid",
+  "uuidv4/1": "uuid",
+  "variant/2": "iso_ext",
+  "vertices_edges_to_ugraph/3": "ugraphs",
+  "vertices/2": "ugraphs",
+  "weighted_maximum/3": "clpb",
+  "when_si/2": "si",
+  "when/2": "when",
+  "zcompare/3": "clpz"
+});
+
+export const eyePrologAmbiguousLibraryAutoload = Object.freeze({});
+
+export const eyePrologLibraryAutoloadModules = Object.freeze([
+  "aggregate",
+  "arithmetic",
+  "assoc",
+  "atts",
+  "between",
+  "charsio",
+  "clpb",
+  "clpz",
+  "comparison",
+  "dates",
+  "dcgs",
+  "debug",
+  "dif",
+  "error",
+  "format",
+  "freeze",
+  "gensym",
+  "iso_ext",
+  "lambda",
+  "lists",
+  "ordsets",
+  "pairs",
+  "pio",
+  "primes",
+  "prologue",
+  "random",
+  "reif",
+  "si",
+  "strings",
+  "tabling",
+  "terms",
+  "time",
+  "ugraphs",
+  "uuid",
+  "when"
+]);

package/src/program.js

@@ -12,11 +12,12 @@ import {
   parseGoalText,
   tryParseClausesFastInto,
 } from './parser.js';
-import { PrologError, convertClauseBodyTerm, getStrictIsoRegistry } from './iso.js';
+import { PrologError, convertClauseBodyTerm, getDefaultRegistry, getStrictIsoRegistry } from './iso.js';
 import { currentWorkingDirectory, fs, path } from './platform.js';
 import {
   standardLibrarySources,
-  eyePrologInteropAutoload,
+  eyePrologAmbiguousLibraryAutoload,
+  eyePrologLibraryAutoload,
   eyePrologInteropLibraryIndicators,
   eyePrologInteropLibraryModules,
 } from './standard-library.js';
@@ -255,7 +256,10 @@ export class Program {
       }
     }
     this.initializations = [];
-    this._initializationsExecuted = false;
+    // Track how many initialization/1 directives have run so a REPL can
+    // autoload a library after startup and execute only that library's newly
+    // appended initializations without repeating earlier side effects.
+    this._initializationsExecutedCount = 0;
     this.quads = [];
     this.prologFlagDirectives = [];
     this.charConversionDirectives = [];
@@ -1045,7 +1049,7 @@ export function autoloadProgramGoals(program, inputs, options = {}) {
     const builder = new ProgramBuilder({ ...options, isoStrict: false }, program);
     const loadedModules = new Set([...program.modules.keys()].filter((name) => name !== 'user'));
     const autoloadCount = program.autoloadedPredicates.length;
-    autoloadInteropDependencies(builder, {
+    autoloadLibraryDependencies(builder, {
       ...options,
       isoStrict: false,
       operatorState,
@@ -1094,7 +1098,7 @@ function loadSourcesIntoBuilder(builder, sources, options, fast) {
       parserFlagState,
     }, builder.program);
     if (options.isoStrict !== true && options.autoload !== false) {
-      autoloadInteropDependencies(builder, {
+      autoloadLibraryDependencies(builder, {
         ...options,
         operatorState,
         parserFlagState,
@@ -1164,14 +1168,32 @@ function extraGoalDependencies(goals) {
   return dependencies;
 }
 
-function interopAutoloadRequests(program, extraGoals = []) {
+function procedureResolvedBeforeAutoload(program, dependency, targetModule) {
+  if (program.findGroup(dependency.name, dependency.arity, targetModule)) return true;
+  return program.moduleImports.get(targetModule)?.has(dependency.key) === true;
+}
+
+function autoloadLibraryFor(dependency) {
+  // ISO built-ins always take precedence over optional library autoloading.
+  if (getDefaultRegistry().get(dependency.name, dependency.arity) != null) return null;
+  const ambiguous = eyePrologAmbiguousLibraryAutoload[dependency.key];
+  if (ambiguous != null) {
+    throw new PrologError(
+      'permission_error(import, procedure)',
+      compound('/', [atom(dependency.name), numberTerm(dependency.arity)]),
+    );
+  }
+  return eyePrologLibraryAutoload[dependency.key] ?? null;
+}
+
+function libraryAutoloadRequests(program, extraGoals = []) {
   const requests = new Map();
   for (const group of program.groups.values()) {
     if (bundledLibraryModule(program, group.module)) continue;
     for (const dependency of groupDependencies(group)) {
       const targetModule = dependency.module ?? group.module;
-      if (program.findGroup(dependency.name, dependency.arity, targetModule)) continue;
-      const library = eyePrologInteropAutoload[dependency.key];
+      if (procedureResolvedBeforeAutoload(program, dependency, targetModule)) continue;
+      const library = autoloadLibraryFor(dependency);
       if (library == null) continue;
       const requestKey = `${targetModule}\u0000${dependency.key}`;
       requests.set(requestKey, {
@@ -1186,8 +1208,8 @@ function interopAutoloadRequests(program, extraGoals = []) {
   for (const goal of program.initializations) {
     for (const dependency of collectGoalDependencies(goal, false, true)) {
       const targetModule = dependency.module ?? 'user';
-      if (program.findGroup(dependency.name, dependency.arity, targetModule)) continue;
-      const library = eyePrologInteropAutoload[dependency.key];
+      if (procedureResolvedBeforeAutoload(program, dependency, targetModule)) continue;
+      const library = autoloadLibraryFor(dependency);
       if (library == null) continue;
       const requestKey = `${targetModule}\u0000${dependency.key}`;
       requests.set(requestKey, {
@@ -1201,8 +1223,8 @@ function interopAutoloadRequests(program, extraGoals = []) {
   }
   for (const dependency of extraGoalDependencies(extraGoals)) {
     const targetModule = dependency.module ?? 'user';
-    if (program.findGroup(dependency.name, dependency.arity, targetModule)) continue;
-    const library = eyePrologInteropAutoload[dependency.key];
+    if (procedureResolvedBeforeAutoload(program, dependency, targetModule)) continue;
+    const library = autoloadLibraryFor(dependency);
     if (library == null) continue;
     const requestKey = `${targetModule}\u0000${dependency.key}`;
     requests.set(requestKey, {
@@ -1216,14 +1238,14 @@ function interopAutoloadRequests(program, extraGoals = []) {
   return [...requests.values()];
 }
 
-function autoloadInteropDependencies(builder, options, ensured, loadedModules, extraGoals = []) {
+function autoloadLibraryDependencies(builder, options, ensured, loadedModules, extraGoals = []) {
   const program = builder.program;
   while (true) {
-    const requests = interopAutoloadRequests(program, extraGoals);
+    const requests = libraryAutoloadRequests(program, extraGoals);
     if (requests.length === 0) return;
     let changed = false;
     for (const request of requests) {
-      if (program.findGroup(request.name, request.arity, request.targetModule)) continue;
+      if (procedureResolvedBeforeAutoload(program, request, request.targetModule)) continue;
       if (!loadedModules.has(request.library)) {
         const designation = compound('library', [atom(request.library)]);
         const loaded = readModuleSource(designation, options);

package/src/repl.js

@@ -4,6 +4,7 @@ import { readSync } from 'node:fs';
 import path from 'node:path';
 import { createInterface } from 'node:readline';
 import { formalErrorTerm } from './iso.js';
+import { autoloadProgramGoals } from './program.js';
 import {
   characterCodeConstantEnd, continuesGraphicToken, isTerminatingFullStop, quotedEscapeEnd,
 } from './syntax-scan.js';
@@ -67,6 +68,19 @@ export async function runRepl(engine, options = {}) {
           continue;
         }
 
+        // Queries entered after the initial Program was prepared need the same
+        // bundled-library autoload resolution as file and -g execution.  This
+        // is intentionally after parsing: predicate autoloading cannot provide
+        // syntax operators retroactively (libraries such as clpz must still be
+        // imported explicitly before their operators are used).
+        if (!state.strictIso && options.autoload !== false) {
+          autoloadProgramGoals(state.program, [goal], {
+            autoload: true,
+            doubleQuotes: state.solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
+          });
+          runWithTerminalSignals(reader, () => state.solver.runInitializations());
+        }
+
         const flagsBefore = snapshotFlagValues(state.solver);
         try {
           await prepareInteractiveTermInput(state, goal, reader);
@@ -284,7 +298,11 @@ function runWithTerminalSignals(reader, operation) {
 
 function makeState(engine, sources, output, options = {}, previousState = null, reader = null) {
   const strictIso = options.isoStrict === true;
-  const program = engine.Program.parseSources(sources, { strictIso, sourceMetadata: strictIso });
+  const program = engine.Program.parseSources(sources, {
+    isoStrict: strictIso,
+    sourceMetadata: strictIso,
+    autoload: !strictIso && options.autoload !== false,
+  });
   const solver = new engine.Solver(program, {
     registry: strictIso ? engine.getStrictIsoRegistry() : engine.getEyePrologRegistry(),
     isoStrict: strictIso,
@@ -756,12 +774,29 @@ function formatAnswer(engine, state, variables, env) {
     collectUnboundVariables(engine, residual, env, names, () => `_${letterName(generated++)}`);
     bindings.push(engine.formatTermForWrite(residual, env, answerWriteOptions));
   }
+  // Residual attributes are part of the answer even when the attributed
+  // variable was created inside a called predicate and is not itself a query
+  // variable (issue #87).  First retain visible query names for attributed
+  // roots, then project every remaining live attributed root with a generated
+  // top-level variable name.  This also makes call_residue_vars/2 useful at the
+  // top level: variables returned through its list share the same name with the
+  // projected constraint instead of appearing unconstrained.
   const projectedAttributeRoots = new Set();
+  const attributeRoots = [];
   for (const variable of variables) {
     const root = engine.deref(variable, env);
-    if (root.type !== 'var' || projectedAttributeRoots.has(root.name) || !env.hasPrologAttributes?.(root.name)) continue;
-    projectedAttributeRoots.add(root.name);
+    if (root.type !== 'var' || !env.hasPrologAttributes?.(root.name)) continue;
     names.set(root.name, variable.name);
+    attributeRoots.push(root);
+  }
+  for (const name of env.attributedVariableNames?.() ?? []) {
+    const root = engine.deref(engine.variable(name), env);
+    if (root.type === 'var') attributeRoots.push(root);
+  }
+  for (const root of attributeRoots) {
+    if (projectedAttributeRoots.has(root.name) || !env.hasPrologAttributes?.(root.name)) continue;
+    projectedAttributeRoots.add(root.name);
+    if (!names.has(root.name)) names.set(root.name, `_${letterName(generated++)}`);
     for (const residual of state.solver.attributeResidualGoals(root, env)) {
       collectUnboundVariables(engine, residual, env, names, () => `_${letterName(generated++)}`);
       bindings.push(engine.formatTermForWrite(residual, env, answerWriteOptions));

package/src/solver.js

@@ -375,18 +375,19 @@ export class Solver {
   }
 
   runInitializations() {
-    if (this.program._initializationsExecuted) return;
-    for (const goal of this.program.initializations ?? []) {
+    const goals = this.program.initializations ?? [];
+    let index = this.program._initializationsExecutedCount ?? 0;
+    for (; index < goals.length; index++) {
       let succeeded = false;
-      for (const _ of this.solve([goal], new Env(), 0)) {
+      for (const _ of this.solve([goals[index]], new Env(), 0)) {
         succeeded = true;
         break;
       }
       if (!succeeded) throw new PrologError('initialization_error');
+      // Mark each successful initialization immediately. If a later one fails,
+      // retrying does not repeat already completed initialization side effects.
+      this.program._initializationsExecutedCount = index + 1;
     }
-    // 7.4.2.6 attaches initialization to preparation of the Prolog text, not
-    // to each later Solver instance created for the same prepared Program.
-    this.program._initializationsExecuted = true;
   }
 
   *solve(goals, env = new Env(), depth = 0) {