eyeprolog 0.5.3

package/src/cli.js

@@ -0,0 +1,238 @@
+// Command-line interface for EyeProlog.
+// It loads programs from files, URLs, or stdin, then runs requested goals.
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import process from 'node:process';
+import { goalsFromSource } from './goal-metadata.js';
+
+let engineModule = null;
+let explanationModule = null;
+
+export async function main(argv) {
+  if (argv.length === 0) {
+    await usage(process.stdout);
+    return;
+  }
+
+  const options = {
+    files: [],
+    proof: false,
+    stats: false,
+    version: false,
+    warnings: false,
+    goals: [],
+  };
+
+  let endOptions = false;
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+
+    if (!endOptions && arg === '--') {
+      endOptions = true;
+    } else if (!endOptions && (arg === '--help' || arg === '-h')) {
+      await usage(process.stdout);
+      return;
+    } else if (!endOptions && (arg === '--proof' || arg === '-p')) {
+      options.proof = true;
+    } else if (!endOptions && (arg === '--stats' || arg === '-s')) {
+      options.stats = true;
+    } else if (!endOptions && (arg === '--version' || arg === '-v')) {
+      options.version = true;
+    } else if (!endOptions && (arg === '--warnings' || arg === '-w')) {
+      options.warnings = true;
+    } else if (!endOptions && arg === '--goal') {
+      const goal = argv[++i];
+      if (goal == null) throw new Error('option --goal requires a goal');
+      options.goals.push(goal);
+    } else if (!endOptions && arg.startsWith('-') && !arg.startsWith('--') && arg.length > 2) {
+      const flags = arg.slice(1);
+      for (const flag of flags) {
+        if (!'hpsvw'.includes(flag)) throw new Error(`unknown option: ${arg}`);
+      }
+      if (flags.includes('h')) {
+        await usage(process.stdout);
+        return;
+      }
+      if (flags.includes('p')) options.proof = true;
+      if (flags.includes('s')) options.stats = true;
+      if (flags.includes('v')) options.version = true;
+      if (flags.includes('w')) options.warnings = true;
+    } else if (!endOptions && arg.startsWith('-') && arg !== '-') {
+      throw new Error(`unknown option: ${arg}`);
+    } else {
+      options.files.push(arg);
+    }
+  }
+
+  if (options.version) {
+    process.stdout.write(`eyeprolog ${await packageVersion()}\n`);
+    return;
+  }
+
+  if (options.files.length === 0) {
+    options.files.push('-');
+  }
+
+  const sourceParts = [];
+  let usedStdin = false;
+
+  for (const file of options.files) {
+    if (file === '-') {
+      if (usedStdin) throw new Error("stdin input '-' can only be used once");
+      usedStdin = true;
+      sourceParts.push({ text: await readStdin(), filename: '<stdin>' });
+    } else if (/^https?:\/\//.test(file)) {
+      const response = await fetch(file);
+      if (!response.ok) throw new Error(`could not fetch URL: ${file}`);
+      sourceParts.push({ text: await response.text(), filename: file });
+    } else {
+      sourceParts.push({
+        text: await fs.readFile(file, 'utf8'),
+        filename: path.basename(file) || file,
+        baseDir: path.dirname(path.resolve(file)),
+      });
+    }
+  }
+
+  if (options.goals.length === 0) {
+    for (const source of sourceParts) options.goals.push(...goalsFromSource(source.text));
+  }
+
+  const engine = await loadEngine();
+  let program = engine.Program.parseSources(sourceParts, { sourceMetadata: options.proof });
+
+  if (options.warnings) printWarnings(program);
+
+  await runDefault(engine, program, options);
+}
+
+async function loadEngine() {
+  if (engineModule == null) {
+    const [term, parser, program, solver, iso, library] = await Promise.all([
+      import('./term.js'),
+      import('./parser.js'),
+      import('./program.js'),
+      import('./solver.js'),
+      import('./iso.js'),
+      import('./library.js'),
+    ]);
+    engineModule = { ...term, ...parser, ...program, ...solver, ...iso, ...library };
+  }
+  return engineModule;
+}
+
+async function loadExplanation() {
+  if (explanationModule == null) explanationModule = await import('./explain.js');
+  return explanationModule;
+}
+
+async function runDefault(engine, program, options) {
+  const goals = options.goals.map((text) => {
+    const goal = engine.parseGoalText(text);
+    if (goal.type === 'var') throw new engine.PrologError('instantiation_error');
+    if (goal.type !== 'atom' && goal.type !== 'compound') throw new engine.PrologError('type_error(callable)', goal);
+    return goal;
+  });
+  const queriedKeys = new Set(goals.map((goal) => `${goal.name}/${goal.arity}`));
+  const facts = program.sourceFactLines(queriedKeys);
+  const lines = new Set();
+  const registry = engine.getEyePrologRegistry();
+  const explanation = options.proof ? await loadExplanation() : null;
+  const solver = new engine.Solver(program, {
+    registry,
+    ioOptions: { write: (text) => process.stdout.write(String(text)) },
+  });
+  program = solver.program;
+  try {
+    solver.runInitializations();
+    for (const goal of goals) {
+      solver.solutionsSeen = 0;
+      for (const env of solver.solve([goal], new engine.Env(), 0)) {
+        if (!engine.termIsGround(goal, env)) continue;
+
+        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(explanation, program, engine.copyResolved(goal, env), registry);
+      }
+    }
+  } catch (error) {
+    if (error?.name !== 'HaltSignal') throw error;
+    process.exitCode = error.code;
+  }
+
+  if (options.stats) printStats(solver.stats);
+}
+
+function writeExplanation(explanation, program, resolved, registry) {
+  const proof = explanation.whyProof(program, resolved, { registry });
+  process.stdout.write(proof.text);
+  if (!proof.ok) process.stdout.write(explanation.whyNoProof(resolved));
+}
+
+async function usage(stream) {
+  stream.write(`eyeprolog ${await packageVersion()}
+
+Usage:
+  eyeprolog [options] [file-or-url.pl|- ...]
+
+Input:
+  file-or-url.pl        Read an EyeProlog program from a local file or http(s) URL.
+  -                     Read an EyeProlog program from standard input.
+
+Options:
+  -h, --help            Show this help text and exit.
+  -p, --proof           Enable proof explanations.
+  -s, --stats           Print solver statistics to stderr after execution.
+  -v, --version         Show the package version and exit.
+  -w, --warnings        Print non-fatal portability warnings to stderr.
+  --goal goal           Solve goal and print its ground answers; may be repeated.
+                        If omitted, use %% goal: comments from the inputs.
+  --                    Stop option parsing; following arguments are treated as files.
+`);
+}
+
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on('end', () => resolve(data));
+    process.stdin.on('error', reject);
+  });
+}
+
+function printWarnings(program) {
+  const errors = program.negationStratificationErrors;
+  if (errors.length === 0) return;
+
+  process.stderr.write('eyeprolog warning: unstratified negation\n');
+  for (const edge of errors) {
+    process.stderr.write(`  ${edge.from} depends negatively on ${edge.to}\n`);
+  }
+}
+
+function printStats(stats) {
+  process.stderr.write('eyeprolog stats:\n');
+  for (const [key, value] of Object.entries(stats)) {
+    process.stderr.write(`  ${key}: ${value}\n`);
+  }
+}
+
+async function packageVersion() {
+  try {
+    const text = await fs.readFile(new URL('../package.json', import.meta.url), 'utf8');
+    const pkg = JSON.parse(text);
+    if (pkg && typeof pkg.version === 'string' && pkg.version) return pkg.version;
+  } catch (_) {
+    // Fall through to a stable marker if package metadata is unavailable.
+  }
+
+  return 'unknown';
+}

package/src/explain.js

@@ -0,0 +1,335 @@
+// EyeProlog proof output helpers.
+// The explanation printer replays a successful goal against the program and emits
+// ordinary EyeProlog facts with nested proof terms.  Explanations are therefore both
+// human-readable and machine-readable.
+import { ATOM, COMPOUND, Env, Term, VAR, deref, flattenConjunction, freshTerm, termToString, unify, variantTerms } from './term.js';
+import { selectClauseCandidates } from './program.js';
+import { getEyePrologRegistry } from './library.js';
+import { Solver, nextFreshId } from './solver.js';
+
+export function whyProof(program, goal, options = {}) {
+  const maxDepth = options.maxDepth ?? 256;
+  const registry = options.registry ?? getEyePrologRegistry();
+  const env = options.env ?? new Env();
+  for (const proof of proveGoalAll(program, goal, env, 0, maxDepth, registry, [])) {
+    return { ok: true, text: renderWhyFacts(goal, proof.node, proof.env) };
+  }
+  return { ok: false, text: '' };
+}
+
+export function whyNoProof(goal) {
+  return renderWhyNoProof(goal);
+}
+
+// Kept for embedders that already import explainProof.  The CLI exposes machine-readable output through whyProof.
+export function explainProof(program, goal, options = {}) {
+  return whyProof(program, goal, options);
+}
+
+function* proveGoalAll(program, goal, env, depth, maxDepth, registry, active) {
+  if (depth > maxDepth) return;
+
+  if (goal.type === COMPOUND && goal.name === ',' && goal.arity === 2) {
+    for (const proved of proveGoalsAll(program, flattenConjunction(goal), env, depth + 1, maxDepth, registry, active)) {
+      yield {
+        env: proved.env,
+        node: {
+          goal: resolveForProof(goal, proved.env),
+          method: 'conjunction',
+          sourceHead: null,
+          sourceBody: flattenConjunction(goal),
+          bindings: [],
+          children: proved.children,
+        },
+      };
+    }
+    return;
+  }
+
+  const builtin = builtinDefinition(program, goal, env, registry);
+  if (builtin.handled) {
+    for (const next of builtinEnvs(builtin.def, builtin.solver, goal, env)) {
+      const proofEnv = next.clone ? next.clone() : next;
+      yield {
+        env: proofEnv,
+        node: {
+          goal: resolveForProof(goal, proofEnv),
+          method: builtinMethod(goal),
+          sourceHead: resolveForProof(goal, proofEnv),
+          sourceBody: [],
+          bindings: [],
+          children: builtinChildren(program, goal, proofEnv, depth + 1, maxDepth, registry, active),
+        },
+      };
+    }
+    return;
+  }
+
+  if (goal.type !== ATOM && goal.type !== COMPOUND) return;
+
+  const group = program.findGroup(goal.name, goal.arity);
+  if (!group) return;
+  // Explanation replay does not use the solver's answer tables, so its cycle
+  // guard applies even when normal execution tables this predicate.
+  if (activeVariant(goal, env, active)) return;
+
+  const candidates = selectClauseCandidates(group, goal, env);
+  for (const pass of [candidates.primary, candidates.fallback]) {
+    for (let candidateIndex = 0; candidateIndex < clauseCandidateLength(pass); candidateIndex++) {
+      const clause = clauseCandidateAt(pass, candidateIndex);
+      const id = nextFreshId();
+      const freshHead = freshTerm(clause.head, id);
+      const freshBody = clause.body.map((term) => freshTerm(term, id));
+      const next = env.clone();
+      if (!unify(goal, freshHead, next)) continue;
+
+      const substitutions = collectClauseSubstitutions(clause, freshHead, freshBody);
+      const bindings = resolvedSubstitutions(substitutions, next);
+
+      if (freshBody.length === 0) {
+        yield {
+          env: next,
+          node: {
+            goal: resolveForProof(goal, next),
+            method: sourceMethod(clause, 'fact'),
+            sourceHead: clause.head,
+            sourceBody: [],
+            bindings,
+            children: [],
+          },
+        };
+        continue;
+      }
+
+      let activePushed = true;
+      active.push({ goal, env });
+      try {
+        for (const proved of proveGoalsAll(program, freshBody, next, depth + 1, maxDepth, registry, active)) {
+          active.pop();
+          activePushed = false;
+          yield {
+            env: proved.env,
+            node: {
+              goal: resolveForProof(goal, proved.env),
+              method: sourceMethod(clause, 'rule'),
+              sourceHead: clause.head,
+              sourceBody: clause.body,
+              bindings: resolvedSubstitutions(substitutions, proved.env),
+              children: proved.children,
+            },
+          };
+          active.push({ goal, env });
+          activePushed = true;
+        }
+      } finally {
+        if (activePushed) active.pop();
+      }
+    }
+  }
+}
+
+function clauseCandidateLength(candidate) {
+  return candidate == null ? 0 : Array.isArray(candidate) ? candidate.length : 1;
+}
+
+function clauseCandidateAt(candidate, index) {
+  return Array.isArray(candidate) ? candidate[index] : index === 0 ? candidate : undefined;
+}
+
+function* proveGoalsAll(program, goals, env, depth, maxDepth, registry, active) {
+  if (goals.length === 0) {
+    yield { env: env.clone(), children: [] };
+    return;
+  }
+
+  const selectedIndex = selectReadyDeterministicBuiltin(goals, env, registry);
+  const goal = goals[selectedIndex];
+  const rest = selectedIndex === 0 ? goals.slice(1) : [...goals.slice(0, selectedIndex), ...goals.slice(selectedIndex + 1)];
+
+  for (const proved of proveGoalAll(program, goal, env, depth, maxDepth, registry, active)) {
+    for (const tail of proveGoalsAll(program, rest, proved.env, depth, maxDepth, registry, active)) {
+      const children = tail.children.slice();
+      children.splice(selectedIndex, 0, proved.node);
+      yield { env: tail.env, children };
+    }
+  }
+}
+
+function builtinDefinition(program, goal, env, registry) {
+  if (goal.type !== ATOM && goal.type !== COMPOUND) return { handled: false, def: null, solver: null };
+  const def = registry.get(goal.name, goal.arity);
+  if (!def) return { handled: false, def: null, solver: null };
+
+  const solver = new Solver(program, { registry });
+  if (!builtinIsUsedForGoal(def, solver, goal, env)) return { handled: false, def: null, solver: null };
+  return { handled: true, def, solver };
+}
+
+function* builtinEnvs(def, solver, goal, env) {
+  for (const next of def.handler({ solver, goal, env })) yield next;
+}
+
+function builtinIsUsedForGoal(def, solver, goal, env) {
+  if (typeof def.shouldUse === 'function' && !def.shouldUse({ solver, goal, env })) return false;
+  if (typeof def.ready !== 'function') return true;
+  if (def.ready(goal, env)) return true;
+  return !def.fallbackWhenNotReady;
+}
+
+function selectReadyDeterministicBuiltin(goals, env, registry) {
+  for (let i = 0; i < goals.length; i++) {
+    const goal = goals[i];
+    if (goal.type !== COMPOUND) continue;
+    const def = registry.get(goal.name, goal.arity);
+    if (!def?.deterministic || typeof def.ready !== 'function') continue;
+    if (typeof def.shouldUse === 'function') continue;
+    if (def.ready(goal, env)) return i;
+  }
+  return 0;
+}
+
+function builtinChildren(program, goal, env, depth, maxDepth, registry, active) {
+  if (goal.type !== COMPOUND) return [];
+  if (goal.name === 'once' && goal.arity === 1) {
+    for (const proved of proveGoalAll(program, goal.args[0], env.clone(), depth, maxDepth, registry, active)) return [proved.node];
+  }
+  return [];
+}
+
+function activeVariant(goal, env, active) {
+  return active.some((entry) => variantTerms(goal, env, entry.goal, entry.env));
+}
+
+function sourceMethod(clause, kind) {
+  const source = clause.source ?? {};
+  return {
+    type: 'source',
+    kind,
+    filename: source.filename ?? '<input>',
+    clause: source.clause ?? ((clause.index ?? 0) + 1),
+  };
+}
+
+function builtinMethod(goal) {
+  return {
+    type: 'builtin',
+    name: goal.type === COMPOUND ? goal.name : 'goal',
+    arity: goal.type === COMPOUND ? goal.arity : 0,
+  };
+}
+
+function renderMethodTerm(method) {
+  if (method && method.type === 'source') return `${method.kind}(${quoteString(method.filename)}, clause(${method.clause}))`;
+  if (method && method.type === 'builtin') return `builtin(${quoteAtomText(method.name)}, ${method.arity})`;
+  return String(method);
+}
+
+function renderWhyFacts(answerGoal, rootNode, env) {
+  const answer = termToString(resolveForProof(answerGoal, env), new Env(), true);
+  return renderWhyTerm(answer, renderAbstractProofTerm(rootNode, 1));
+}
+
+function renderWhyNoProof(goal) {
+  const answer = termToString(resolveForProof(goal, new Env()), new Env(), true);
+  return renderWhyTerm(answer, `${indent(1)}no_proof`);
+}
+
+function renderWhyTerm(answer, proofTerm) {
+  return ['why(', `${indent(1)}${answer},`, proofTerm, ').', '', ''].join('\n');
+}
+
+function renderAbstractProofTerm(node, level) {
+  const goal = termToString(node.goal, new Env(), true);
+  const hasTail = node.bindings.length || node.children.length;
+  const lines = [
+    `${indent(level)}proof(`,
+    `${indent(level + 1)}goal(${goal}),`,
+    `${indent(level + 1)}by(${renderMethodTerm(node.method)})${hasTail ? ',' : ''}`,
+  ];
+
+  if (node.bindings.length) lines.push(`${indent(level + 1)}${renderBindingsTerm(node.bindings)}${node.children.length ? ',' : ''}`);
+  if (node.children.length) lines.push(renderUsesTerm(node.children, level + 1));
+
+  lines.push(`${indent(level)})`);
+  return lines.join('\n');
+}
+
+function renderUsesTerm(children, level) {
+  const lines = [`${indent(level)}uses([`];
+  for (let i = 0; i < children.length; i++) {
+    const item = renderAbstractProofTerm(children[i], level + 1);
+    lines.push(i === children.length - 1 ? item : withTrailingComma(item));
+  }
+  lines.push(`${indent(level)}])`);
+  return lines.join('\n');
+}
+
+function renderBindingsTerm(bindings) {
+  return `bindings(${renderProofListInline(bindings, binding => `binding(${quoteString(binding.name)}, ${termToString(binding.value, new Env(), true)})`)})`;
+}
+
+function renderProofListInline(items, renderItem) {
+  return `[${items.map(item => renderItem(item)).join(', ')}]`;
+}
+
+function withTrailingComma(text) {
+  const lines = String(text).split('\n');
+  lines[lines.length - 1] += ',';
+  return lines.join('\n');
+}
+
+function indent(level) {
+  return '  '.repeat(level);
+}
+
+function quoteAtomText(text) {
+  return termToString({ type: 'atom', name: String(text), args: [] }, new Env(), true);
+}
+
+function quoteString(value) {
+  return JSON.stringify(String(value));
+}
+
+function originalVariableName(name) {
+  return String(name).replace(/#\d+$/, '');
+}
+
+function resolveForProof(term, env) {
+  const resolved = deref(term, env);
+  if (resolved.type === VAR) return new Term(VAR, originalVariableName(resolved.name), []);
+  return new Term(resolved.type, resolved.name, resolved.args.map((arg) => resolveForProof(arg, env)));
+}
+
+function collectClauseSubstitutions(clause, freshHead, freshBody) {
+  const substitutions = [];
+  const seen = new Set();
+  collectSubstitutions(clause.head, freshHead, substitutions, seen);
+  for (let i = 0; i < clause.body.length && i < freshBody.length; i++) {
+    collectSubstitutions(clause.body[i], freshBody[i], substitutions, seen);
+  }
+  return substitutions;
+}
+
+function collectSubstitutions(original, fresh, substitutions, seen) {
+  if (!original || !fresh) return;
+  if (original.type === VAR) {
+    if (!seen.has(original.name)) {
+      seen.add(original.name);
+      substitutions.push({ name: original.name, fresh });
+    }
+    return;
+  }
+  if (original.type !== COMPOUND || fresh.type !== COMPOUND) return;
+  const arity = Math.min(original.arity, fresh.arity);
+  for (let i = 0; i < arity; i++) collectSubstitutions(original.args[i], fresh.args[i], substitutions, seen);
+}
+
+function resolvedSubstitutions(substitutions, env) {
+  const out = [];
+  for (const substitution of substitutions) {
+    const resolved = deref(substitution.fresh, env);
+    if (resolved.type === VAR) continue;
+    out.push({ name: substitution.name, value: resolveForProof(substitution.fresh, env) });
+  }
+  return out;
+}

package/src/goal-metadata.js

@@ -0,0 +1,17 @@
+// Host-supplied goal metadata embedded in ordinary Prolog comments.
+// The source remains valid ISO Prolog text because processors may ignore it.
+export function goalsFromSource(source) {
+  const goals = [];
+  const lines = String(source ?? '').split(/\r?\n/);
+  for (let index = 0; index < lines.length; index++) {
+    const match = lines[index].match(/^\s*%%\s*goal:\s*(.*)$/);
+    if (!match) continue;
+    let goal = match[1];
+    while (lines[index + 1]?.match(/^\s*%%/) && !lines[index + 1].match(/^\s*%%\s*goal:/)) {
+      index++;
+      goal += `\n${lines[index].replace(/^\s*%%\s?/, '')}`;
+    }
+    goals.push(goal.trim());
+  }
+  return goals;
+}

package/src/index.js

@@ -0,0 +1,88 @@
+// 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, parseGoalText, parseProgramText } from './parser.js';
+export { Solver } from './solver.js';
+export * from './term.js';
+export {
+  BuiltinRegistry,
+  createDefaultRegistry,
+  getDefaultRegistry,
+  HaltSignal,
+  PrologError,
+} from './iso.js';
+export {
+  createEyePrologRegistry,
+  getEyePrologRegistry,
+} from './library.js';
+export { StreamManager } from './io.js';
+
+import { ATOM, COMPOUND, VAR, Env, copyResolved, termIsGround, termToString } from './term.js';
+import { Program } from './program.js';
+import { Solver } from './solver.js';
+import { whyNoProof, whyProof } from './explain.js';
+import { HaltSignal, PrologError } from './iso.js';
+import { getEyePrologRegistry } from './library.js';
+import { parseGoalText } from './parser.js';
+
+export function run(source, options = {}) {
+  const includeWhy = options.proof === true || options.why === true || options.explain === true;
+  const parseOptions = { ...options, sourceMetadata: includeWhy };
+  let program = source instanceof Program ? source : Program.parse(source, parseOptions);
+  const runOptions = options.registry ? options : { ...options, registry: getEyePrologRegistry() };
+  const output = [];
+  const solver = new Solver(program, {
+    ...runOptions,
+    ioOptions: {
+      ...(options.ioOptions ?? {}),
+      write: (text) => {
+        const rendered = String(text);
+        output.push(rendered);
+        options.ioOptions?.write?.(rendered);
+      },
+    },
+  });
+  program = solver.program;
+  const goals = normalizeGoals(options);
+  const queriedKeys = new Set(goals.map((goal) => `${goal.name}/${goal.arity}`));
+  const facts = program.sourceFactLines(queriedKeys);
+  const seen = new Set();
+  let haltCode = null;
+  try {
+    solver.runInitializations();
+    for (const goal of goals) {
+      solver.solutionsSeen = 0;
+      for (const env of solver.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);
+      }
+    }
+  } catch (error) {
+    if (!(error instanceof HaltSignal)) throw error;
+    haltCode = error.code;
+  }
+  return { stdout: output.join(''), stats: solver.stats, haltCode };
+}
+
+function normalizeGoals(options) {
+  const requested = options.goals ?? (options.goal == null ? [] : [options.goal]);
+  return requested.map((requestedGoal) => {
+    const goal = typeof requestedGoal === 'string' ? parseGoalText(requestedGoal) : requestedGoal;
+    if (goal.type === VAR) throw new PrologError('instantiation_error');
+    if (goal.type !== ATOM && goal.type !== COMPOUND) throw new PrologError('type_error(callable)', goal);
+    return goal;
+  });
+}
+
+function appendExplanation(output, program, resolved, registry) {
+  const proof = whyProof(program, resolved, { registry });
+  output.push(proof.text);
+  if (!proof.ok) output.push(whyNoProof(resolved));
+}
+
+export * from './explain.js';