eyeprolog 1.3.28 → 1.3.30

package/README.md

@@ -158,7 +158,7 @@ avoiding benchmark sizes that require multi-gigabyte collectors on some
 engines. Run EyeProlog's complete profile with:
 
 ```sh
-./openrulebench/run-eyeprolog.sh
+./openrulebench/run-eyeprolog.mjs
 ```
 
 The benchmark README records the expected answer counts. Timing values are
@@ -291,8 +291,11 @@ and Scryer (`scryer-prolog`) installed, run:
 npm run test:interop
 ```
 
-The GitHub interoperability workflow builds both implementations and runs the
-same portable Towers of Hanoi source under EyeProlog, Trealla, and Scryer.
+This optional check runs the same portable Towers of Hanoi source under
+EyeProlog, Trealla, and Scryer. The default `npm test` does not require external
+Prolog implementations; it does validate all four generated OpenRuleBench
+source trees and their engine-specific tabling and WFS adaptations. Run those
+fast structural checks separately with `npm run test:openrulebench`.
 
 ## Development
 
@@ -303,4 +306,8 @@ npm install
 npm test
 ```
 
+The GitHub test workflow runs the complete suite and an npm package dry-run on
+both the minimum supported Node.js 18 release line and Node.js 24. Publishing
+repeats those release checks before uploading the package.
+
 EyeProlog is released under the [MIT License](LICENSE.md).

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.3.28",
+  "version": "1.3.30",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",
@@ -51,6 +51,7 @@
     "test:conformance": "node test/run-conformance.mjs",
     "test:iso-strict": "node test/run-iso-strict.mjs",
     "test:interop": "node test/run-interop.mjs",
+    "test:openrulebench": "node test/run-openrulebench.mjs",
     "test:wg17": "node test/run-wg17.mjs",
     "test:examples": "node test/run-examples.mjs",
     "test:regression": "node test/run-regression.mjs",

package/src/index.js

@@ -28,7 +28,7 @@ export { StreamManager } from './io.js';
 export { runQuads } from './quads.js';
 
 import { ATOM, COMPOUND, VAR, Env, copyResolved, termIsGround } from './term.js';
-import { Program } from './program.js';
+import { Program, autoloadProgramGoals } from './program.js';
 import { Solver } from './solver.js';
 import { whyNoProof, whyProof } from './explain.js';
 import { HaltSignal, PrologError, getStrictIsoRegistry } from './iso.js';
@@ -49,6 +49,7 @@ export function run(source, options = {}) {
     autoloadGoals: requestedGoals,
   };
   let program = source instanceof Program ? source : Program.parse(source, parseOptions);
+  if (source instanceof Program) autoloadProgramGoals(program, requestedGoals, options);
   const strictIso = requestedStrictIso || program.strictIso === true;
   const runOptions = strictIso
     ? { ...options, isoStrict: true, registry: getStrictIsoRegistry() }

package/src/program.js

@@ -706,6 +706,48 @@ function buildProgramFromSources(sources, options) {
   return builder.finish();
 }
 
+// Program.parse() can see host-supplied goals through autoloadGoals while it
+// builds the program. A Program passed directly to run() has already completed
+// that phase, so extend the existing instance with the same canonical interop
+// imports before solving those goals. Keeping this here lets both paths share
+// the dependency analysis and module-loading rules.
+export function autoloadProgramGoals(program, inputs, options = {}) {
+  if (inputs == null || (Array.isArray(inputs) && inputs.length === 0)) return program;
+  const operatorState = createParserOperatorState(
+    [...program.operators.values()],
+    false,
+    { isoStrict: program.strictIso },
+  );
+  const parserFlagState = { doubleQuotes: program.doubleQuotes ?? options.doubleQuotes ?? 'chars' };
+  const goals = parseInteropGoalInputs(inputs, {
+    ...options,
+    isoStrict: program.strictIso,
+    operatorState,
+    parserFlagState,
+  }, program);
+
+  if (!program.strictIso && options.autoload !== false) {
+    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, {
+      ...options,
+      isoStrict: false,
+      operatorState,
+      parserFlagState,
+    }, new Set(), loadedModules, goals);
+    if (program.autoloadedPredicates.length !== autoloadCount) {
+      // Existing Solver instances key their tables by Program revision, and a
+      // previously requested negation analysis is no longer complete once new
+      // library groups become reachable.
+      program.noteMutation(false);
+      builder.finish();
+    }
+  }
+  analyzeInteropPortability(program, goals);
+  return program;
+}
+
 function loadSourcesIntoBuilder(builder, sources, options, fast) {
   const ensured = new Set();
   const loadedModules = new Set();

package/test/run-all.mjs

@@ -10,6 +10,7 @@ import { runPlayground } from './run-playground.mjs';
 import { runExamples } from './run-examples.mjs';
 import { runBookExamples } from './run-book-examples.mjs';
 import { runWg17 } from './run-wg17.mjs';
+import { runOpenRuleBenchChecks } from './run-openrulebench.mjs';
 
 const reporter = new TestReporter();
 
@@ -17,6 +18,7 @@ try {
   runConformance(reporter);
   runIsoStrict(reporter);
   runWg17(reporter);
+  runOpenRuleBenchChecks(reporter);
   runRegression(reporter);
   await runPlayground(reporter);
   runExamples(reporter);

package/test/run-openrulebench.mjs

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+// Fast structural checks for the generated multi-engine OpenRuleBench corpus.
+// Full benchmark execution remains separate because it requires external
+// Prolog implementations and is intentionally performance-oriented.
+import path from 'node:path';
+import process from 'node:process';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { TestReporter, isMainModule } from './test-style.mjs';
+
+const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+
+export function runOpenRuleBenchChecks(reporter = new TestReporter()) {
+  reporter.section('OpenRuleBench source integrity');
+  runChecker(
+    reporter,
+    'generated sources pass lexical checks',
+    'openrulebench/tools/check_sources.mjs',
+    'eyeprolog: 14 sources; lexical checks ok',
+  );
+  runChecker(
+    reporter,
+    'engine variants preserve table and WFS adaptations',
+    'openrulebench/tools/check_multiengine.mjs',
+    'OK: 14 benchmarks x 4 engines; table/WFS adaptations verified.',
+  );
+  reporter.sectionTotal('OpenRuleBench source-integrity');
+}
+
+function runChecker(reporter, name, relativeScript, expectedOutput) {
+  reporter.test(name, () => {
+    const result = spawnSync(process.execPath, [relativeScript], {
+      cwd: packageRoot,
+      encoding: 'utf8',
+      timeout: 30000,
+    });
+    if (result.error) throw result.error;
+    if (result.status !== 0) {
+      throw new Error(
+        `${relativeScript} exited with ${result.status}\n` +
+        `${result.stdout ?? ''}${result.stderr ?? ''}`.trimEnd(),
+      );
+    }
+    if (!String(result.stdout).includes(expectedOutput)) {
+      throw new Error(`${relativeScript} did not report its expected summary\n${result.stdout ?? ''}`.trimEnd());
+    }
+  });
+}
+
+if (isMainModule(import.meta.url)) {
+  const reporter = new TestReporter();
+  try {
+    runOpenRuleBenchChecks(reporter);
+    reporter.totalLine();
+  } catch (_) {
+    process.exit(1);
+  }
+}

package/test/run-regression.mjs

@@ -3407,6 +3407,23 @@ function documentationSyncCases() {
       name: 'documented npm scripts exist in package.json',
       run: () => assertArrayEqual(missingDocumentedPackageScripts(), [], 'missing documented npm scripts'),
     },
+    {
+      name: 'CI verifies the supported Node floor and gates npm publishing',
+      run: () => {
+        const testWorkflow = fs.readFileSync(path.join(packageRoot, '.github', 'workflows', 'test.yml'), 'utf8');
+        assertIncludes(testWorkflow, "node-version: ['18', '24']", 'test workflow Node matrix');
+        assertIncludes(testWorkflow, 'run: npm test', 'test workflow suite');
+        assertIncludes(testWorkflow, 'run: npm pack --dry-run', 'test workflow package check');
+
+        const publishWorkflow = fs.readFileSync(path.join(packageRoot, '.github', 'workflows', 'publish-npm.yml'), 'utf8');
+        const testIndex = publishWorkflow.indexOf('run: npm test');
+        const packIndex = publishWorkflow.indexOf('run: npm pack --dry-run');
+        const publishIndex = publishWorkflow.indexOf('run: npm publish');
+        assertEqual(testIndex >= 0 && testIndex < publishIndex, true, 'publish workflow test gate');
+        assertEqual(packIndex >= 0 && packIndex < publishIndex, true, 'publish workflow package gate');
+        assertEqual(pkg.scripts?.['test:openrulebench'], 'node test/run-openrulebench.mjs', 'OpenRuleBench test script');
+      },
+    },
     {
       name: 'documented conformance totals match the generated report',
       run: () => assertArrayEqual(documentedConformanceMetricIssues(), [], 'documented conformance totals'),
@@ -3856,6 +3873,21 @@ answer(ok) :-
         assertEqual(result.stdout, 'member(a, "ab").\nmember(b, "ab").\n', 'stdout');
       },
     },
+    {
+      name: 'JavaScript run autoloads top-level goals for parsed Program instances',
+      run: () => {
+        const program = Program.parse('');
+        const revision = program.revision;
+        program.stratifiedNegation;
+        const result = runEyeProlog(program, { goal: 'member(X,[a,b])' });
+        assertEqual(result.stdout, 'member(a, "ab").\nmember(b, "ab").\n', 'stdout');
+        assertEqual(program.findGroup('member', 2)?.module, 'lists', 'autoloaded Program predicate');
+        assertEqual(program.autoloadedPredicates.map((entry) => `${entry.indicator}:${entry.library}`).join(','),
+          'member/2:lists', 'autoload metadata');
+        assertEqual(program.revision, revision + 1, 'Program revision after autoload');
+        assertEqual(program.stratifiedNegation, true, 'negation metadata recomputed after autoload');
+      },
+    },
     {
       name: 'JavaScript run can disable top-level goal autoloading',
       run: () => {

package/the-art-of-eyeprolog.md

@@ -1819,6 +1819,11 @@ additional logical answer.
 `analyzeNegation`. It returns `stdout`, the solver's numeric `stats`, and a
 nullable `haltCode`; it does not write to the process streams.
 
+When `run` receives an already parsed `Program`, canonical interop imports
+needed only by its host-supplied goals are added to that Program before solving,
+just as they are while source text is parsed. Pass `autoload: false` when the
+Program must retain only explicitly imported predicates.
+
 For applications that inspect or prepare a theory before running it, use
 `Program` directly:
 
@@ -6302,8 +6307,10 @@ calls to non-profile predicates from otherwise common modules. `--portable`
 turns those diagnostics into a failing run, making the conservative profile
 suitable for continuous integration. `npm run test:interop` executes the same
 portable Towers of Hanoi source under EyeProlog, Trealla, and Scryer when those commands
-are installed; the repository interoperability workflow installs them and runs
-that check.
+are installed. Because those are external runtimes, the default `npm test`
+instead validates all four generated OpenRuleBench source trees and their
+engine-specific tabling and WFS adaptations without requiring them. The fast
+structural check is also available directly as `npm run test:openrulebench`.
 
 #### Library notes beyond the interoperability profile