eyelang 1.4.0 → 1.5.0

package/src/index.js

@@ -1,52 +1,45 @@
 // Public JavaScript API surface for embedders and the browser playground.
 // The CLI imports the same parser, program, solver, and term primitives from here.
 export { Program, makeProgram } from './program.js';
-export { parseClauses, parseProgramText, parseQueryGoal } from './parser.js';
+export { parseClauses, parseProgramText } 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));
-    }
-  } else {
-    const goals = program.materializationGoals();
-    const materializedKeys = new Set(goals.map((goal) => `${goal.name}/${goal.arity}`));
-    const facts = program.sourceFactLines(materializedKeys);
-    const seen = new Set();
-    for (const goal of goals) {
-      const localSolver = new Solver(program, options);
-      for (const env of localSolver.solve([goal], new Env(), 0)) {
-        const resolved = copyResolved(goal, env);
-        if (!termIsGround(resolved)) continue;
-        const line = `${termToString(resolved, new Env(), true)}.\n`;
-        if (facts.has(line) || seen.has(line)) continue;
-        seen.add(line);
-        output.push(line);
-        if (includeWhy) appendExplanation(output, program, resolved);
-      }
+  const goals = program.materializationGoals();
+  const materializedKeys = new Set(goals.map((goal) => `${goal.name}/${goal.arity}`));
+  const facts = program.sourceFactLines(materializedKeys);
+  const seen = new Set();
+  for (const goal of goals) {
+    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;
+      const line = `${termToString(resolved, new Env(), true)}.\n`;
+      if (facts.has(line) || seen.has(line)) continue;
+      seen.add(line);
+      output.push(line);
+      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/src/parser.js

@@ -399,9 +399,9 @@ export function parseProgramText(source) {
   return parseClauses(source);
 }
 
-export function parseQueryGoal(query) {
-  const clauses = parseClauses(`q(${query}).`);
+export function parseGoalText(text) {
+  const clauses = parseClauses(`zz_goal(${text}).`);
   const head = clauses[0]?.head;
-  if (!head || head.args.length < 1) throw new Error('bad query');
+  if (!head || head.args.length < 1) throw new Error('bad goal');
   return head.args[0];
 }

package/src/solver.js

@@ -31,7 +31,7 @@ export class Solver {
     };
   }
 
-  cloneForSubquery(solutionLimit = this.solutionLimit) {
+  cloneForInnerGoal(solutionLimit = this.solutionLimit) {
     const solver = new Solver(this.program, { registry: this.registry, maxDepth: this.maxDepth, solutionLimit });
     solver.memo = this.memo;
     return solver;
@@ -114,7 +114,7 @@ export class Solver {
     }
     if (!entry.complete && !entry.computing) {
       entry.computing = true;
-      const collector = this.cloneForSubquery();
+      const collector = this.cloneForInnerGoal();
       for (const answerEnv of collector.solveUserGoalUncached(group, goal, [], env.clone(), depth)) {
         entry.answers.push(goal.args.map((arg) => importResolved(arg, answerEnv)));
       }

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,40 @@ 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);
-  const queryFile = path.join(casesDir, `${name}.query`);
+function runCase(profile, name, file, casesDir, expectedDir) {
+  const programFile = path.join(casesDir, file);
   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 actual = run(program).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>'}`;
     }
   }
 

package/test/run-regression.js

@@ -30,8 +30,8 @@ import {
   unify,
   variantTerms,
   parseProgramText,
-  parseQueryGoal,
 } from '../src/index.js';
+import { parseGoalText } from '../src/parser.js';
 import { selectClauseCandidates } from '../src/program.js';
 import { TestReporter, isMainModule } from './test-style.js';
 
@@ -61,7 +61,7 @@ function regressionCases() {
       name: '--proof rule fact explanation output',
       run: () => runWhy({
         program: 'type(socrates, man).\ntype(X, mortal) :- type(X, man).\n',
-        query: 'type(socrates, mortal)',
+        goalText: 'type(socrates, mortal)',
         expected: `type(socrates, mortal).
 why(
   type(socrates, mortal),
@@ -84,8 +84,8 @@ why(
     {
       name: '--proof numeric builtin explanation output',
       run: () => runWhy({
-        program: 'p(X) :- between(4, 1000, X).\n',
-        query: 'p(536)',
+        program: 'p(X) :- between(536, 536, X).\n',
+        goalText: 'p(536)',
         expected: `p(536).
 why(
   p(536),
@@ -95,7 +95,7 @@ why(
     bindings([binding("X", 536)]),
     uses([
       proof(
-        goal(between(4, 1000, 536)),
+        goal(between(536, 536, 536)),
         by(builtin(between, 3))
       )
     ])
@@ -108,8 +108,8 @@ why(
     {
       name: '--proof list builtin explanation output',
       run: () => runWhy({
-        program: 'p(X) :- member(X, [a, b]).\n',
-        query: 'p(a)',
+        program: 'p(X) :- member(X, [a]).\n',
+        goalText: 'p(a)',
         expected: `p(a).
 why(
   p(a),
@@ -119,7 +119,7 @@ why(
     bindings([binding("X", a)]),
     uses([
       proof(
-        goal(member(a, [a, b])),
+        goal(member(a, [a])),
         by(builtin(member, 2))
       )
     ])
@@ -134,7 +134,7 @@ why(
       run: () => {
         const result = runWhyLoose({
           program: 'p(ok) :- q(X), r(X).\nq(a).\nq(b).\nr(b).\n',
-          query: 'p(ok)',
+          goalText: 'p(ok)',
         });
         assertIncludes(result.stdout, 'goal(q(b)),\n        by(fact("', 'stdout');
         assertIncludes(result.stdout, 'goal(r(b)),\n        by(fact("', 'stdout');
@@ -146,7 +146,7 @@ why(
       run: () => {
         const result = runWhyLoose({
           program: 'p(ok) :- q(1), q(1).\nq(0).\nq(1) :- q(0).\n',
-          query: 'p(ok)',
+          goalText: 'p(ok)',
         });
         assertIncludes(result.stdout, 'goal(p(ok)),\n    by(rule("', 'stdout');
         assertIncludes(result.stdout, 'goal(q(1)),\n        by(rule("', 'stdout');
@@ -156,12 +156,12 @@ why(
     {
       name: 'EYELANG_LOCAL_TIME fixes local_time builtin',
       run: () => {
-        const result = runCli(['--query', 'local_time(D)', '-'], {
-          input: '',
+        const result = runCli(['-'], {
+          input: 'materialize(local_time_answer, 1).\nlocal_time_answer(D) :- local_time(D).\n',
           env: { EYELANG_LOCAL_TIME: '2024-01-02' },
         });
         assertEqual(result.status, 0, 'exit status');
-        assertEqual(result.stdout, 'local_time("2024-01-02").\n', 'stdout');
+        assertEqual(result.stdout, 'local_time_answer("2024-01-02").\n', 'stdout');
         assertEqual(result.stderr, '', 'stderr');
       },
     },
@@ -171,7 +171,6 @@ why(
         const result = runCli([]);
         assertEqual(result.status, 0, 'exit status');
         assertIncludes(result.stdout, 'Usage:\n  eyelang [options] [file-or-url.pl|- ...]', 'stdout');
-        assertIncludes(result.stdout, '--query GOAL', 'stdout');
         assertIncludes(result.stdout, '--proof', 'stdout');
         assertEqual(result.stderr, '', 'stderr');
       },
@@ -198,21 +197,20 @@ why(
     {
       name: 'stdin input is accepted',
       run: () => {
-        const result = runCli(['--query', 'p(X)', '-'], { input: 'p(a).\np(b).\n' });
+        const result = runCli(['-'], { input: 'p(a, b).\nq(X, Y) :- p(X, Y).\n' });
         assertEqual(result.status, 0, 'exit status');
-        assertEqual(result.stdout, 'p(a).\np(b).\n', 'stdout');
+        assertEqual(result.stdout, 'q(a, b).\n', 'stdout');
         assertEqual(result.stderr, '', 'stderr');
       },
     },
 
 
     {
-      name: '--proof enables query explanations',
+      name: '--proof enables materialization explanations',
       run: () => {
-        const result = runCli(['--proof', '--query', 'p(X)', '-'], { input: 'p(a).\np(b).\n' });
+        const result = runCli(['--proof', '-'], { input: 'p(a, b).\nq(X, Y) :- p(X, Y).\n' });
         assertEqual(result.status, 0, 'exit status');
-        assertIncludes(result.stdout, 'p(a).\nwhy(', 'stdout');
-        assertIncludes(result.stdout, 'p(b).\nwhy(', 'stdout');
+        assertIncludes(result.stdout, 'q(a, b).\nwhy(', 'stdout');
         assertEqual(result.stderr, '', 'stderr');
       },
     },
@@ -238,26 +236,11 @@ why(
         assertEqual(result.stderr, '', 'stderr');
       },
     },
-    {
-      name: 'missing query argument fails clearly',
-      run: () => {
-        const result = runCli(['--query']);
-        assertEqual(result.status, 1, 'exit status');
-        assertIncludes(result.stderr, 'eyelang: --query requires an argument', 'stderr');
-      },
-    },
   ];
 }
 
 function apiCases() {
   return [
-    {
-      name: 'run query through public API without proof by default',
-      run: () => {
-        const result = run('parent(pat, jan).\nancestor(X, Y) :- parent(X, Y).\n', { query: 'ancestor(pat, Y)' });
-        assertEqual(result.stdout, 'ancestor(pat, jan).\n', 'stdout');
-      },
-    },
     {
       name: 'run materialization through public API without proof by default',
       run: () => {
@@ -267,14 +250,6 @@ function apiCases() {
     },
 
 
-    {
-      name: 'run query can enable proof explanations',
-      run: () => {
-        const result = run('p(a).\np(b).\n', { query: 'p(X)', proof: true });
-        assertIncludes(result.stdout, 'p(a).\nwhy(', 'stdout');
-        assertIncludes(result.stdout, 'p(b).\nwhy(', 'stdout');
-      },
-    },
     {
       name: 'run materialization can enable proof explanations',
       run: () => {
@@ -286,9 +261,9 @@ function apiCases() {
     {
       name: 'run accepts Program instances',
       run: () => {
-        const program = Program.parse('p(a).\np(b).\n');
-        const result = run(program, { query: 'p(X)' });
-        assertEqual(result.stdout, 'p(a).\np(b).\n', 'stdout');
+        const program = Program.parse('p(a, b).\nq(X, Y) :- p(X, Y).\n');
+        const result = run(program);
+        assertEqual(result.stdout, 'q(a, b).\n', 'stdout');
       },
     },
     {
@@ -306,7 +281,7 @@ function apiCases() {
       run: () => {
         const program = Program.parse('p(a).\np(b).\n');
         const solver = new Solver(program);
-        const goal = parseQueryGoal('p(X)');
+        const goal = parseGoalText('p(X)');
         const answers = [...solver.solve([goal], new Env(), 0)].map((env) => termToString(goal, env, true));
         assertEqual(answers.join('\n'), 'p(a)\np(b)', 'answers');
       },
@@ -316,7 +291,7 @@ function apiCases() {
       run: () => {
         const program = Program.parse('p(a).\np(b).\np(c).\n');
         const solver = new Solver(program, { solutionLimit: 2 });
-        const goal = parseQueryGoal('p(X)');
+        const goal = parseGoalText('p(X)');
         const answers = [...solver.solve([goal], new Env(), 0)].map((env) => termToString(goal, env, true));
         assertEqual(answers.join('\n'), 'p(a)\np(b)', 'answers');
       },
@@ -331,7 +306,7 @@ function apiCases() {
         });
         const program = Program.parse('answer(X) :- hello(X).\n');
         const solver = new Solver(program, { registry });
-        const goal = parseQueryGoal('answer(X)');
+        const goal = parseGoalText('answer(X)');
         const answers = [...solver.solve([goal], new Env(), 0)].map((env) => termToString(goal, env, true));
         assertEqual(answers.join('\n'), 'answer(world)', 'answers');
       },
@@ -376,7 +351,7 @@ function whiteBoxCases() {
     {
       name: 'parser preserves list syntax readback',
       run: () => {
-        const goal = parseQueryGoal('member(X, [a, b])');
+        const goal = parseGoalText('member(X, [a, b])');
         assertEqual(termToString(goal, new Env(), true), 'member(X, [a, b])', 'goal');
       },
     },
@@ -392,9 +367,9 @@ function whiteBoxCases() {
     {
       name: 'variantTerms recognizes alpha-equivalent goals',
       run: () => {
-        const left = parseQueryGoal('edge(X, Y)');
-        const right = parseQueryGoal('edge(A, B)');
-        const nonVariant = parseQueryGoal('edge(A, A)');
+        const left = parseGoalText('edge(X, Y)');
+        const right = parseGoalText('edge(A, B)');
+        const nonVariant = parseGoalText('edge(A, A)');
         assertEqual(variantTerms(left, new Env(), right, new Env()), true, 'variant');
         assertEqual(variantTerms(left, new Env(), nonVariant, new Env()), false, 'non-variant');
       },
@@ -402,7 +377,7 @@ function whiteBoxCases() {
     {
       name: 'flattenConjunction preserves left-to-right order',
       run: () => {
-        const goal = parseQueryGoal('(a, b, c)');
+        const goal = parseGoalText('(a, b, c)');
         const parts = flattenConjunction(goal).map((part) => termToString(part, new Env(), true));
         assertEqual(parts.join(' | '), 'a | b | c', 'order');
       },
@@ -421,7 +396,7 @@ function whiteBoxCases() {
       run: () => {
         const program = Program.parse('edge(a, b).\nedge(c, d).\nedge(X, z).\n');
         const group = program.findGroup('edge', 2);
-        const goal = parseQueryGoal('edge(a, Y)');
+        const goal = parseGoalText('edge(a, Y)');
         const candidates = selectClauseCandidates(group, goal, new Env());
         assertEqual(candidates.primary.length, 1, 'primary bucket length');
         assertEqual(candidates.fallback.length, 1, 'fallback length');
@@ -443,10 +418,12 @@ function sectionLabel(name) {
   return name.toLowerCase();
 }
 
-function runWhy({ program, query, expected }) {
+function runWhy({ program, goalText, expected }) {
   const programFile = path.join(tmp, `${++tmpCounter}.pl`);
   fs.writeFileSync(programFile, program);
-  const result = runCli(['--proof', '--query', query, programFile]);
+  const goal = parseGoalText(goalText);
+  fs.appendFileSync(programFile, `\nmaterialize(${goal.name}, ${goal.arity}).\n`);
+  const result = runCli(['--proof', programFile]);
   assertEqual(result.status, 0, 'exit status');
   assertEqual(result.stderr, '', 'stderr');
   const expectedText = expected.replaceAll('__FILE__', path.basename(programFile));
@@ -460,10 +437,12 @@ function runWhy({ program, query, expected }) {
   assertIncludes(result.stdout, '\n).\n\n', 'stdout');
 }
 
-function runWhyLoose({ program, query }) {
+function runWhyLoose({ program, goalText }) {
   const programFile = path.join(tmp, `${++tmpCounter}.pl`);
   fs.writeFileSync(programFile, program);
-  const result = runCli(['--proof', '--query', query, programFile]);
+  const goal = parseGoalText(goalText);
+  fs.appendFileSync(programFile, `\nmaterialize(${goal.name}, ${goal.arity}).\n`);
+  const result = runCli(['--proof', programFile]);
   assertEqual(result.status, 0, 'exit status');
   assertEqual(result.stderr, '', 'stderr');
   Program.parse(result.stdout);

package/conformance/cases/core/001_fact_query.pl

@@ -1,2 +0,0 @@
-% SPEC 6, 7, 11: facts are queryable and printed as resolved terms.
-parent(pat, jan).