eyelang 1.4.0 → 1.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyelang",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "type": "module",
   "description": "A small rule engine for Prolog-style Horn clauses",
   "keywords": [

package/src/builtins/registry.js

@@ -44,3 +44,10 @@ export function createDefaultRegistry() {
   }
   return registry;
 }
+
+let defaultRegistry = null;
+
+export function getDefaultRegistry() {
+  if (defaultRegistry == null) defaultRegistry = createDefaultRegistry();
+  return defaultRegistry;
+}

package/src/cli.js

@@ -3,17 +3,13 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import process from 'node:process';
-import { Env, copyResolved, termIsGround, termToString } from './term.js';
-import { Program } from './program.js';
-import { Solver } from './solver.js';
-import { parseQueryGoal } from './parser.js';
-import { whyNoProof, whyProof } from './explain.js';
 
-const VERSION = await packageVersion();
+let engineModule = null;
+let explanationModule = null;
 
 export async function main(argv) {
   if (argv.length === 0) {
-    usage(process.stdout);
+    await usage(process.stdout);
     return;
   }
 
@@ -35,7 +31,7 @@ export async function main(argv) {
     } else if (!endOptions && (arg === '--version' || arg === '-v')) {
       options.version = true;
     } else if (!endOptions && (arg === '--help' || arg === '-h')) {
-      usage(process.stdout);
+      await usage(process.stdout);
       return;
     } else if (!endOptions && (arg === '--proof' || arg === '-p')) {
       options.proof = true;
@@ -52,7 +48,7 @@ export async function main(argv) {
   }
 
   if (options.version) {
-    process.stdout.write(`eyelang ${VERSION}\n`);
+    process.stdout.write(`eyelang ${await packageVersion()}\n`);
     return;
   }
 
@@ -77,45 +73,69 @@ export async function main(argv) {
     }
   }
 
-  const program = Program.parseSources(sourceParts, { sourceMetadata: options.proof, markRecursive: options.proof });
+  const engine = await loadEngine();
+  const program = engine.Program.parseSources(sourceParts, { sourceMetadata: options.proof, markRecursive: options.proof });
 
-  if (options.query != null) runQuery(program, options.query, options);
-  else runDefault(program, options);
+  if (options.query != null) await runQuery(engine, program, options.query, options);
+  else await runDefault(engine, program, options);
 }
 
-function runQuery(program, query, options) {
-  const goal = parseQueryGoal(query);
-  const solver = new Solver(program);
+async function loadEngine() {
+  if (engineModule == null) {
+    const [term, program, solver, parser, registry] = await Promise.all([
+      import('./term.js'),
+      import('./program.js'),
+      import('./solver.js'),
+      import('./parser.js'),
+      import('./builtins/registry.js'),
+    ]);
+    engineModule = { ...term, ...program, ...solver, ...parser, ...registry };
+  }
+  return engineModule;
+}
+
+async function loadExplanation() {
+  if (explanationModule == null) explanationModule = await import('./explain.js');
+  return explanationModule;
+}
+
+async function runQuery(engine, program, query, options) {
+  const goal = engine.parseQueryGoal(query);
+  const registry = engine.getDefaultRegistry();
+  const solver = new engine.Solver(program, { registry });
+  const explanation = options.proof ? await loadExplanation() : null;
 
-  for (const env of solver.solve([goal], new Env(), 0)) {
-    process.stdout.write(`${termToString(goal, env, true)}.\n`);
+  for (const env of solver.solve([goal], new engine.Env(), 0)) {
+    process.stdout.write(`${engine.termToString(goal, env, true)}.\n`);
 
-    if (options.proof) writeExplanation(program, copyResolved(goal, env));
+    if (options.proof) writeExplanation(explanation, program, engine.copyResolved(goal, env), registry);
   }
 
   if (options.stats) printStats(solver.stats);
 }
 
-function runDefault(program, options) {
+async function runDefault(engine, program, options) {
   const goals = program.materializationGoals();
   const materializedKeys = new Set(goals.map((goal) => `${goal.name}/${goal.arity}`));
   const facts = program.sourceFactLines(materializedKeys);
   const lines = new Set();
   let lastStats = null;
+  const registry = engine.getDefaultRegistry();
+  const explanation = options.proof ? await loadExplanation() : null;
 
   for (const goal of goals) {
-    const solver = new Solver(program);
+    const solver = new engine.Solver(program, { registry });
 
-    for (const env of solver.solve([goal], new Env(), 0)) {
-      if (!termIsGround(goal, env)) continue;
+    for (const env of solver.solve([goal], new engine.Env(), 0)) {
+      if (!engine.termIsGround(goal, env)) continue;
 
-      const line = `${termToString(goal, env, true)}.\n`;
+      const line = `${engine.termToString(goal, env, true)}.\n`;
       if (facts.has(line) || lines.has(line)) continue;
 
       lines.add(line);
 
       process.stdout.write(line);
-      if (options.proof) writeExplanation(program, copyResolved(goal, env));
+      if (options.proof) writeExplanation(explanation, program, engine.copyResolved(goal, env), registry);
     }
 
     lastStats = solver.stats;
@@ -124,14 +144,14 @@ function runDefault(program, options) {
   if (options.stats && lastStats) printStats(lastStats);
 }
 
-function writeExplanation(program, resolved) {
-  const proof = whyProof(program, resolved);
+function writeExplanation(explanation, program, resolved, registry) {
+  const proof = explanation.whyProof(program, resolved, { registry });
   process.stdout.write(proof.text);
-  if (!proof.ok) process.stdout.write(whyNoProof(resolved));
+  if (!proof.ok) process.stdout.write(explanation.whyNoProof(resolved));
 }
 
-function usage(stream) {
-  stream.write(`eyelang ${VERSION}
+async function usage(stream) {
+  stream.write(`eyelang ${await packageVersion()}
 
 Usage:
   eyelang [options] [file-or-url.pl|- ...]

package/src/index.js

@@ -4,25 +4,27 @@ export { Program, makeProgram } from './program.js';
 export { parseClauses, parseProgramText, parseQueryGoal } from './parser.js';
 export { Solver } from './solver.js';
 export * from './term.js';
-export { BuiltinRegistry, createDefaultRegistry } from './builtins/registry.js';
+export { BuiltinRegistry, createDefaultRegistry, getDefaultRegistry } from './builtins/registry.js';
 
 import { Env, copyResolved, termIsGround, termToString } from './term.js';
 import { Program } from './program.js';
 import { Solver } from './solver.js';
 import { parseQueryGoal } from './parser.js';
 import { whyNoProof, whyProof } from './explain.js';
+import { getDefaultRegistry } from './builtins/registry.js';
 
 export function run(source, options = {}) {
   const includeWhy = options.proof === true || options.why === true || options.explain === true;
   const parseOptions = { ...options, sourceMetadata: includeWhy, markRecursive: includeWhy };
   const program = source instanceof Program ? source : Program.parse(source, parseOptions);
-  const solver = new Solver(program, options);
+  const runOptions = options.registry ? options : { ...options, registry: getDefaultRegistry() };
+  const solver = new Solver(program, runOptions);
   const output = [];
   if (options.query) {
     const goal = typeof options.query === 'string' ? parseQueryGoal(options.query) : options.query;
     for (const env of solver.solve([goal], new Env(), 0)) {
       output.push(`${termToString(goal, env, true)}.\n`);
-      if (includeWhy) appendExplanation(output, program, copyResolved(goal, env));
+      if (includeWhy) appendExplanation(output, program, copyResolved(goal, env), runOptions.registry);
     }
   } else {
     const goals = program.materializationGoals();
@@ -30,7 +32,7 @@ export function run(source, options = {}) {
     const facts = program.sourceFactLines(materializedKeys);
     const seen = new Set();
     for (const goal of goals) {
-      const localSolver = new Solver(program, options);
+      const localSolver = new Solver(program, runOptions);
       for (const env of localSolver.solve([goal], new Env(), 0)) {
         const resolved = copyResolved(goal, env);
         if (!termIsGround(resolved)) continue;
@@ -38,15 +40,15 @@ export function run(source, options = {}) {
         if (facts.has(line) || seen.has(line)) continue;
         seen.add(line);
         output.push(line);
-        if (includeWhy) appendExplanation(output, program, resolved);
+        if (includeWhy) appendExplanation(output, program, resolved, runOptions.registry);
       }
     }
   }
   return { stdout: output.join(''), stats: solver.stats };
 }
 
-function appendExplanation(output, program, resolved) {
-  const proof = whyProof(program, resolved);
+function appendExplanation(output, program, resolved, registry) {
+  const proof = whyProof(program, resolved, { registry });
   output.push(proof.text);
   if (!proof.ok) output.push(whyNoProof(resolved));
 }

package/test/run-conformance.js

@@ -1,31 +1,22 @@
 #!/usr/bin/env node
 // Conformance test runner.
-// It executes each case through the CLI so tests cover the same path users run from the shell.
+// It executes cases in-process so the conformance corpus measures engine behavior instead of Node process startup.
 import fs from 'node:fs';
-import os from 'node:os';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
+import { Program, run } from '../src/index.js';
 import { fileURLToPath } from 'node:url';
 import { TestReporter, isMainModule } from './test-style.js';
 
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const bin = path.join(root, 'bin', 'eyelang');
 const profileArg = process.argv[2] ?? 'conformance';
 
 export function runConformance(reporter = new TestReporter(), requestedProfiles = null) {
   const profiles = requestedProfiles ?? (profileArg === 'conformance' ? ['core', 'extension'] : [profileArg]);
-  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'eyelang-conformance.'));
-  const actualFile = path.join(tmp, 'actual.out');
-  const errFile = path.join(tmp, 'stderr.out');
-
-  try {
-    for (const profile of profiles) runProfile(reporter, profile, actualFile, errFile);
-  } finally {
-    fs.rmSync(tmp, { recursive: true, force: true });
-  }
+  for (const profile of profiles) runProfile(reporter, profile);
 }
 
-function runProfile(reporter, profile, actualFile, errFile) {
+function runProfile(reporter, profile) {
   const casesDir = path.join(root, 'conformance', 'cases', profile);
   const expectedDir = path.join(root, 'conformance', 'expected', profile);
 
@@ -38,56 +29,42 @@ function runProfile(reporter, profile, actualFile, errFile) {
   for (const file of files) {
     const name = file.slice(0, -3);
     const label = `${profile}/${name}`;
-    reporter.test(label, () => runCase(profile, name, file, casesDir, expectedDir, actualFile, errFile));
+    reporter.test(label, () => runCase(profile, name, file, casesDir, expectedDir));
   }
 
   reporter.sectionTotal(`conformance ${profile}`);
 }
 
-function runCase(profile, name, file, casesDir, expectedDir, actualFile, errFile) {
-  const program = path.join(casesDir, file);
+function runCase(profile, name, file, casesDir, expectedDir) {
+  const programFile = path.join(casesDir, file);
   const queryFile = path.join(casesDir, `${name}.query`);
   const expected = path.join(expectedDir, `${name}.out`);
-  const args = [bin];
-  if (fs.existsSync(queryFile)) args.push('--query', fs.readFileSync(queryFile, 'utf8').trim());
-  args.push(program);
-
-  const outFd = fs.openSync(actualFile, 'w');
-  const errFd = fs.openSync(errFile, 'w');
-  const result = spawnSync(process.execPath, args, {
-    cwd: root,
-    stdio: ['ignore', outFd, errFd],
-  });
-  fs.closeSync(outFd);
-  fs.closeSync(errFd);
-
-  if (result.status !== 0) {
-    const stderr = fs.readFileSync(errFile, 'utf8');
-    const stdout = fs.readFileSync(actualFile, 'utf8');
-    throw new Error(`case ${profile}/${name} exited with ${result.status}\n${stderr}${stdout}`.trimEnd());
-  }
+  const text = fs.readFileSync(programFile, 'utf8');
+  const program = Program.parseSources([{ text, filename: file }], { sourceMetadata: false, markRecursive: false });
+  const options = fs.existsSync(queryFile) ? { query: fs.readFileSync(queryFile, 'utf8').trim() } : {};
+  const actual = run(program, options).stdout;
 
   if (!fs.existsSync(expected)) {
     throw new Error(`missing expected file: ${path.relative(root, expected)}`);
   }
 
-  const expectedBuffer = fs.readFileSync(expected);
-  const actualBuffer = fs.readFileSync(actualFile);
-  if (!expectedBuffer.equals(actualBuffer)) {
-    throw new Error(`output mismatch for ${profile}/${name}\n${diffText(expected, actualFile)}`.trimEnd());
+  const expectedText = fs.readFileSync(expected, 'utf8');
+  if (expectedText !== actual) {
+    throw new Error(`output mismatch for ${profile}/${name}
+${diffText(expected, actual)}`.trimEnd());
   }
 }
 
-function diffText(expected, actual) {
-  const diff = spawnSync('diff', ['-u', expected, actual], { encoding: 'utf8' });
+function diffText(expected, actualText) {
+  const diff = spawnSync('diff', ['-u', expected, '-'], { input: actualText, encoding: 'utf8' });
   if (diff.stdout) return diff.stdout;
 
   const expectedText = fs.readFileSync(expected, 'utf8').split('\n');
-  const actualText = fs.readFileSync(actual, 'utf8').split('\n');
-  const limit = Math.max(expectedText.length, actualText.length);
+  const actualLines = actualText.split('\n');
+  const limit = Math.max(expectedText.length, actualLines.length);
   for (let i = 0; i < limit; i++) {
-    if (expectedText[i] !== actualText[i]) {
-      return `first difference at line ${i + 1}\nexpected: ${expectedText[i] ?? '<missing>'}\nactual:   ${actualText[i] ?? '<missing>'}`;
+    if (expectedText[i] !== actualLines[i]) {
+      return `first difference at line ${i + 1}\nexpected: ${expectedText[i] ?? '<missing>'}\nactual:   ${actualLines[i] ?? '<missing>'}`;
     }
   }
 

package/test/run-examples.js

@@ -2,14 +2,13 @@
 // Example-output test runner.
 // It compares examples byte-for-byte against golden output so answer and proof changes cannot silently alter results.
 import fs from 'node:fs';
-import os from 'node:os';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
+import { Program, run } from '../src/index.js';
 import { fileURLToPath } from 'node:url';
 import { TestReporter, isMainModule } from './test-style.js';
 
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const bin = path.join(root, 'bin', 'eyelang');
 const examplesDir = path.join(root, 'examples');
 const expectedDir = path.join(examplesDir, 'output');
 const expectedProofDir = path.join(examplesDir, 'proof');
@@ -39,77 +38,70 @@ const proofExamples = [
 ];
 
 export function runExamples(reporter = new TestReporter()) {
-  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'eyelang-examples.'));
-  const actualFile = path.join(tmp, 'actual.out');
-  const errFile = path.join(tmp, 'stderr.out');
+  const files = fs.readdirSync(examplesDir)
+    .filter((name) => name.endsWith('.pl'))
+    .sort();
 
-  try {
-    const files = fs.readdirSync(examplesDir)
-      .filter((name) => name.endsWith('.pl'))
-      .sort();
-
-    reporter.section('Examples');
-    for (const name of files) reporter.test(name, () => runExample(name, actualFile, errFile));
-    reporter.sectionTotal('examples');
+  reporter.section('Examples');
+  for (const name of files) reporter.test(name, () => runExample(name));
+  reporter.sectionTotal('examples');
 
-    reporter.section('Proof examples');
-    for (const name of proofExamples) reporter.test(name, () => runProofExample(name, actualFile, errFile));
-    reporter.sectionTotal('proof examples');
-  } finally {
-    fs.rmSync(tmp, { recursive: true, force: true });
-  }
+  reporter.section('Proof examples');
+  for (const name of proofExamples) reporter.test(name, () => runProofExample(name));
+  reporter.sectionTotal('proof examples');
 }
 
-function runExample(name, actualFile, errFile) {
-  const program = path.join(examplesDir, name);
+function runExample(name) {
+  const programFile = path.join(examplesDir, name);
   const expected = path.join(expectedDir, name);
-  runAndCompare(name, program, expected, [], actualFile, errFile, 'output');
+  const actual = runProgramExample(programFile, name, { proof: false });
+  compareOutput(name, expected, actual, 'output');
 }
 
-function runProofExample(name, actualFile, errFile) {
-  const program = path.join(examplesDir, name);
+function runProofExample(name) {
+  const programFile = path.join(examplesDir, name);
   const expected = path.join(expectedProofDir, name);
-  runAndCompare(name, program, expected, ['--proof'], actualFile, errFile, 'proof output');
+  const actual = runProgramExample(programFile, name, { proof: true });
+  compareOutput(name, expected, actual, 'proof output');
 }
 
-function runAndCompare(name, program, expected, args, actualFile, errFile, label) {
-  const outFd = fs.openSync(actualFile, 'w');
-  const errFd = fs.openSync(errFile, 'w');
-  const result = spawnSync(process.execPath, [bin, ...args, program], {
-    cwd: root,
-    env: { ...process.env, EYELANG_LOCAL_TIME: fixedExampleDate },
-    stdio: ['ignore', outFd, errFd],
-  });
-  fs.closeSync(outFd);
-  fs.closeSync(errFd);
-
-  if (result.status !== 0) {
-    const stderr = fs.readFileSync(errFile, 'utf8');
-    const stdout = fs.readFileSync(actualFile, 'utf8');
-    throw new Error(`example ${name} ${label} exited with ${result.status}\n${stderr}${stdout}`.trimEnd());
+function runProgramExample(programFile, filename, options) {
+  const oldLocalTime = process.env.EYELANG_LOCAL_TIME;
+  process.env.EYELANG_LOCAL_TIME = fixedExampleDate;
+  try {
+    const text = fs.readFileSync(programFile, 'utf8');
+    const program = Program.parseSources([{ text, filename }], {
+      sourceMetadata: options.proof,
+      markRecursive: options.proof,
+    });
+    return run(program, options).stdout;
+  } finally {
+    if (oldLocalTime == null) delete process.env.EYELANG_LOCAL_TIME;
+    else process.env.EYELANG_LOCAL_TIME = oldLocalTime;
   }
+}
 
+function compareOutput(name, expected, actual, label) {
   if (!fs.existsSync(expected)) {
     throw new Error(`missing expected ${label} file: ${path.relative(root, expected)}`);
   }
 
-  const expectedBuffer = fs.readFileSync(expected);
-  const actualBuffer = fs.readFileSync(actualFile);
-  if (!expectedBuffer.equals(actualBuffer)) {
-    throw new Error(`${label} mismatch for ${name}\n${diffText(expected, actualFile)}`.trimEnd());
+  const expectedText = fs.readFileSync(expected, 'utf8');
+  if (expectedText !== actual) {
+    throw new Error(`${label} mismatch for ${name}\n${diffText(expected, actual)}`.trimEnd());
   }
 }
 
-function diffText(expected, actual) {
-  const diff = spawnSync('diff', ['-u', expected, actual], { encoding: 'utf8' });
+function diffText(expected, actualText) {
+  const diff = spawnSync('diff', ['-u', expected, '-'], { input: actualText, encoding: 'utf8' });
   if (diff.stdout) return diff.stdout;
 
   const expectedText = fs.readFileSync(expected, 'utf8').split('\n');
-  const actualText = fs.readFileSync(actual, 'utf8').split('\n');
-  const limit = Math.max(expectedText.length, actualText.length);
+  const actualLines = actualText.split('\n');
+  const limit = Math.max(expectedText.length, actualLines.length);
   for (let i = 0; i < limit; i++) {
-    if (expectedText[i] !== actualText[i]) {
-      return `first difference at line ${i + 1}\nexpected: ${expectedText[i] ?? '<missing>'}\nactual:   ${actualText[i] ?? '<missing>'}`;
+    if (expectedText[i] !== actualLines[i]) {
+      return `first difference at line ${i + 1}\nexpected: ${expectedText[i] ?? '<missing>'}\nactual:   ${actualLines[i] ?? '<missing>'}`;
     }
   }