eyeprolog 0.5.3

package/test/run-examples.mjs

@@ -0,0 +1,184 @@
+#!/usr/bin/env node
+// 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 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.mjs';
+import { goalsInProgramOrder } from './goal-metadata.mjs';
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)));
+const packageRoot = path.resolve(root, '..');
+const examplesDir = path.join(packageRoot, 'examples');
+const expectedDir = path.join(examplesDir, 'output');
+const expectedProofDir = path.join(examplesDir, 'proof');
+const fixedExampleDate = '2026-05-30';
+
+export const proofExamples = [
+  'access-control-policy.pl',
+  'age.pl',
+  'aliases-and-namespaces.pl',
+  'ancestor.pl',
+  'animal.pl',
+  'annotation.pl',
+  'backward.pl',
+  'bayes-diagnosis.pl',
+  'cat-koko.pl',
+  'context-association.pl',
+  'data-negotiation.pl',
+  'deontic-logic.pl',
+  'derived-backward-rule.pl',
+  'derived-rule.pl',
+  'dog.pl',
+  'electrical-rc-filter.pl',
+  'existential-rule.pl',
+  'floating-point.pl',
+  'good-cobbler.pl',
+  'graph-reachability.pl',
+  'greatest-lower-bound-uniqueness.pl',
+  'group-inverse-uniqueness.pl',
+  'herbrand-semantics.pl',
+  'list-collection.pl',
+  'proof-contrapositive.pl',
+  'reusable-builtins.pl',
+  'socket-age.pl',
+  'socket-family.pl',
+  'socrates.pl',
+  'spacecraft-battery-diagnosis.pl',
+  'term-tools.pl',
+  'witch.pl',
+  'beam-deflection.pl',
+  'cache-performance.pl',
+  'canary-release.pl',
+  'chart-parser.pl',
+  'clinical-trial-screening.pl',
+  'composition-of-injective-functions-is-injective.pl',
+  'diamond-property.pl',
+  'dpv-odrl-purpose-mapping.pl',
+  'epidemic-policy.pl',
+  'equivalence-classes-overlap-implies-same-class.pl',
+  'expression-eval.pl',
+  'gdpr-compliance.pl',
+  'hanoi.pl',
+  'heat-loss.pl',
+  'herbrand-witnesses.pl',
+  'ideal-gas-law.pl',
+  'intuitionistic-logic-kripke.pl',
+  'linear-logic-resources.pl',
+  'modal-logic-kripke.pl',
+  'nixon-diamond.pl',
+  'security-incident-correlation.pl',
+  'symbolic-derivative.pl',
+  'trust-flow-provenance-threshold.pl',
+  'rdf12-annotation.pl',
+  'rdf12-triple-term.pl',
+  'rdf12-nested-triple-term.pl',
+  'rdf12-trig-triple-term.pl',
+  'weighted-interval-scheduling.pl',
+  'rdf12-trig-graph-join.pl',
+  'rdf12-directional-language.pl',
+  'odrl-policy-from-turtle.pl',
+  'integrity-check.pl',
+  'rdf12-trig-named-graph.pl',
+  'prime-range.pl',
+  'd3-group.pl',
+  'iso-operators.pl',
+  'web-names.pl',
+  'iso-dynamic-database.pl',
+  'partial-evaluator.pl',
+];
+
+export function runExamples(reporter = new TestReporter()) {
+  const files = fs.readdirSync(examplesDir)
+    .filter((name) => exampleIsRunnable(name))
+    .sort();
+
+  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));
+  reporter.sectionTotal('proof examples');
+}
+
+
+function exampleIsRunnable(name) {
+  return name.endsWith('.pl');
+}
+
+function runExample(name) {
+  const programFile = path.join(examplesDir, name);
+  const expected = path.join(expectedDir, name);
+  const actual = runProgramExample(programFile, name, { proof: false });
+  compareOutput(name, expected, actual, 'output');
+}
+
+function runProofExample(name) {
+  const programFile = path.join(examplesDir, name);
+  const expected = path.join(expectedProofDir, name);
+  const actual = runProgramExample(programFile, name, { proof: true });
+  compareOutput(name, expected, actual, 'proof output');
+}
+
+function runProgramExample(programFile, filename, options) {
+  const oldLocalTime = process.env.EYEPROLOG_LOCAL_TIME;
+  process.env.EYEPROLOG_LOCAL_TIME = fixedExampleDate;
+  try {
+    const text = fs.readFileSync(programFile, 'utf8');
+    const expectedExit = text.match(/^%\s*expect-exit:\s*(\d+)\s*$/m);
+    const program = Program.parseSources([{ text, filename }], {
+      sourceMetadata: options.proof,
+    });
+    try {
+      const result = run(program, { ...options, goals: goalsInProgramOrder(program, text) });
+      if (expectedExit) throw new Error(`${filename} expected exit ${expectedExit[1]}, but reasoning succeeded`);
+      return result.stdout;
+    } catch (error) {
+      if (expectedExit && error?.code === Number(expectedExit[1])) return error.stdout ?? '';
+      throw error;
+    }
+  } finally {
+    if (oldLocalTime == null) delete process.env.EYEPROLOG_LOCAL_TIME;
+    else process.env.EYEPROLOG_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 expectedText = fs.readFileSync(expected, 'utf8');
+  if (expectedText !== actual) {
+    throw new Error(`${label} mismatch for ${name}\n${diffText(expected, actual)}`.trimEnd());
+  }
+}
+
+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 actualLines = actualText.split('\n');
+  const limit = Math.max(expectedText.length, actualLines.length);
+  for (let i = 0; i < limit; i++) {
+    if (expectedText[i] !== actualLines[i]) {
+      return `first difference at line ${i + 1}\nexpected: ${expectedText[i] ?? '<missing>'}\nactual:   ${actualLines[i] ?? '<missing>'}`;
+    }
+  }
+
+  return 'outputs differ';
+}
+
+if (isMainModule(import.meta.url)) {
+  const reporter = new TestReporter();
+  try {
+    runExamples(reporter);
+    reporter.totalLine();
+  } catch (_) {
+    process.exit(1);
+  }
+}

package/test/run-playground.mjs

@@ -0,0 +1,224 @@
+#!/usr/bin/env node
+// Browser-playground contract tests.
+// These checks use only Node built-ins, but exercise the exact worker module
+// and HTTP module graph used by playground.html.
+import fs from 'node:fs';
+import http from 'node:http';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import {
+  executePlaygroundRequest,
+  installPlaygroundWorker,
+} from '../src/playground-worker.js';
+import { TestReporter, isMainModule } from './test-style.mjs';
+
+const testRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)));
+const packageRoot = path.resolve(testRoot, '..');
+
+export async function runPlayground(reporter = new TestReporter()) {
+  reporter.section('Playground');
+
+  await reporter.testAsync('page starts a dedicated module worker', async () => {
+    const html = fs.readFileSync(path.join(packageRoot, 'playground.html'), 'utf8');
+    assertIncludes(html, "new URL('./src/playground-worker.js?playground=", 'playground worker URL');
+    assertIncludes(html, "new Worker(workerUrl, { type: 'module' })", 'module worker construction');
+    assertNotIncludes(html, 'URL.createObjectURL(new Blob([workerCode]', 'inline blob worker');
+  });
+
+  await reporter.testAsync('worker loads append/3 from the EyeProlog library', async () => {
+    const result = executePlaygroundRequest({
+      source: 'answer(X) :- append([a], [b], X).\n',
+      options: { goal: 'answer(X)' },
+    }, deterministicClock());
+    assertEqual(result.ok, true, 'worker result status');
+    assertEqual(result.stdout, 'answer([a, b]).\n', 'append/3 output');
+    assertEqual(result.elapsedMs, 1, 'elapsed time');
+  });
+
+  await reporter.testAsync('worker keeps the EyeProlog library across runs', async () => {
+    const first = executePlaygroundRequest({
+      source: 'answer(X) :- reverse([a, b, c], X).\n',
+      options: { goal: 'answer(X)' },
+    });
+    const second = executePlaygroundRequest({
+      source: 'answer(X) :- member(X, [red, green]).\n',
+      options: { goal: 'answer(X)' },
+    });
+    assertEqual(first.stdout, 'answer([c, b, a]).\n', 'first worker output');
+    assertEqual(second.stdout, 'answer(red).\nanswer(green).\n', 'second worker output');
+  });
+
+  await reporter.testAsync('worker message protocol returns serializable results', async () => {
+    const messages = [];
+    const scope = { postMessage: (message) => messages.push(message) };
+    installPlaygroundWorker(scope);
+    scope.onmessage({
+      data: {
+        source: 'answer(X) :- append([], [ok], X).\n',
+        options: { goal: 'answer(X)', stats: true },
+      },
+    });
+    assertEqual(messages.length, 1, 'posted message count');
+    assertEqual(messages[0].ok, true, 'posted result status');
+    assertEqual(messages[0].stdout, 'answer([ok]).\n', 'posted result output');
+    JSON.stringify(messages[0]);
+  });
+
+  await reporter.testAsync('worker serializes parse failures for the UI', async () => {
+    const result = executePlaygroundRequest({
+      source: 'broken(.\n',
+      options: { goal: 'answer' },
+    });
+    assertEqual(result.ok, false, 'parse result status');
+    assertIncludes(result.error, 'parse line 1', 'parse error');
+    JSON.stringify(result);
+  });
+
+  await reporter.testAsync('served playground assets have browser-safe MIME types', async () => {
+    await withStaticServer(async (baseUrl) => {
+      const expected = [
+        ['playground.html', 'text/html'],
+        ['src/playground-worker.js', 'text/javascript'],
+        ['src/index.js', 'text/javascript'],
+        ['examples/socrates.pl', 'text/plain'],
+      ];
+      for (const [relative, contentType] of expected) {
+        const response = await fetch(new URL(relative, baseUrl));
+        assertEqual(response.status, 200, `${relative} status`);
+        assertIncludes(response.headers.get('content-type') ?? '', contentType, `${relative} content type`);
+      }
+    });
+  });
+
+  await reporter.testAsync('HTTP worker module graph resolves without Node built-ins', async () => {
+    await withStaticServer(async (baseUrl) => {
+      const modules = await crawlModuleGraph(new URL('src/playground-worker.js?playground=test', baseUrl));
+      assert(modules.size >= 10, `expected a substantial worker module graph, got ${modules.size}`);
+      assert([...modules].some((url) => url.includes('/src/library.js')), 'EyeProlog library missing from worker graph');
+      assert([...modules].some((url) => url.includes('/src/solver.js')), 'solver missing from worker graph');
+    });
+  });
+
+  reporter.sectionTotal('playground');
+}
+
+async function crawlModuleGraph(entryUrl) {
+  const pending = [entryUrl];
+  const visited = new Set();
+  while (pending.length) {
+    const url = pending.pop();
+    const key = url.href;
+    if (visited.has(key)) continue;
+    visited.add(key);
+
+    const response = await fetch(url);
+    assertEqual(response.status, 200, `${url.pathname} status`);
+    assertIncludes(response.headers.get('content-type') ?? '', 'text/javascript', `${url.pathname} content type`);
+    const source = await response.text();
+    for (const specifier of staticModuleSpecifiers(source)) {
+      assert(!specifier.startsWith('node:'), `${url.pathname} statically imports ${specifier}`);
+      if (!specifier.startsWith('.') && !specifier.startsWith('/')) continue;
+      const child = new URL(specifier, url);
+      assertEqual(child.origin, entryUrl.origin, `${url.pathname} import origin`);
+      pending.push(child);
+    }
+  }
+  return visited;
+}
+
+function staticModuleSpecifiers(source) {
+  const specifiers = [];
+  const sideEffectImports = /(?:^|\n)\s*import\s*['"]([^'"]+)['"]/g;
+  const fromImports = /(?:^|\n)\s*(?:import|export)\s+[^;]*?\s+from\s+['"]([^'"]+)['"]/g;
+  for (const match of source.matchAll(sideEffectImports)) specifiers.push(match[1]);
+  for (const match of source.matchAll(fromImports)) specifiers.push(match[1]);
+  return specifiers;
+}
+
+async function withStaticServer(run) {
+  const server = http.createServer((request, response) => {
+    try {
+      const url = new URL(request.url ?? '/', 'http://127.0.0.1');
+      const relative = decodeURIComponent(url.pathname).replace(/^\/+/, '') || 'playground.html';
+      const filename = path.resolve(packageRoot, relative);
+      if (filename !== packageRoot && !filename.startsWith(`${packageRoot}${path.sep}`)) {
+        response.writeHead(403).end('forbidden');
+        return;
+      }
+      if (!fs.statSync(filename, { throwIfNoEntry: false })?.isFile()) {
+        response.writeHead(404).end('not found');
+        return;
+      }
+      response.writeHead(200, {
+        'Content-Type': contentType(filename),
+        'Cache-Control': 'no-store',
+        'Connection': 'close',
+      });
+      fs.createReadStream(filename).pipe(response);
+    } catch (error) {
+      response.writeHead(500).end(String(error));
+    }
+  });
+
+  await new Promise((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(0, '127.0.0.1', resolve);
+  });
+  try {
+    const address = server.address();
+    await run(new URL(`http://127.0.0.1:${address.port}/`));
+  } finally {
+    await new Promise((resolve, reject) => {
+      server.close((error) => error ? reject(error) : resolve());
+      server.closeAllConnections?.();
+    });
+  }
+}
+
+function contentType(filename) {
+  switch (path.extname(filename)) {
+    case '.html': return 'text/html; charset=utf-8';
+    case '.js':
+    case '.mjs': return 'text/javascript; charset=utf-8';
+    case '.json': return 'application/json; charset=utf-8';
+    case '.png': return 'image/png';
+    default: return 'text/plain; charset=utf-8';
+  }
+}
+
+function deterministicClock() {
+  let value = 0;
+  return () => value++;
+}
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+function assertEqual(actual, expected, label) {
+  if (actual !== expected) {
+    throw new Error(`${label} mismatch\nexpected: ${JSON.stringify(expected)}\nactual:   ${JSON.stringify(actual)}`);
+  }
+}
+
+function assertIncludes(actual, expected, label) {
+  if (!String(actual).includes(expected)) {
+    throw new Error(`${label} did not include ${JSON.stringify(expected)}\nactual: ${JSON.stringify(actual)}`);
+  }
+}
+
+function assertNotIncludes(actual, expected, label) {
+  if (String(actual).includes(expected)) {
+    throw new Error(`${label} unexpectedly included ${JSON.stringify(expected)}`);
+  }
+}
+
+if (isMainModule(import.meta.url)) {
+  const reporter = new TestReporter();
+  try {
+    await runPlayground(reporter);
+    reporter.totalLine();
+  } catch (_) {
+    process.exit(1);
+  }
+}

package/test/run-rdf-tools.mjs

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import { compileRdfDocumentToEyeProlog, compileRdfToEyeProlog } from '../tools/rdf-to-pl.mjs';
+import { extractEyePrologRdf } from '../tools/pl-to-rdf.mjs';
+import { run } from '../src/index.js';
+import { TestReporter, isMainModule } from './test-style.mjs';
+
+export async function runRdfTools(reporter = new TestReporter()) {
+  reporter.section('RDF tools');
+  reporter.test('N-Quads survives an include-source round trip', () => {
+    const input = '<https://example/s> <https://example/p> "chat"@fr <https://example/g> .\n_:a <https://example/value> "42"^^<http://www.w3.org/2001/XMLSchema#integer> .\n';
+    const output = run(compileRdfToEyeProlog(input, { scope: 'doc', includeSource: true }), { goal: 'rdf(S, P, O, G)' }).stdout;
+    equal(extractEyePrologRdf(output), '<https://example/s> <https://example/p> "chat"@fr <https://example/g> .\n_:e646f63_61 <https://example/value> "42"^^<http://www.w3.org/2001/XMLSchema#integer> .\n');
+  });
+  reporter.test('default mode emits only rule-derived quads', () => {
+    const input = '<https://example/s> <https://example/parent> <https://example/o> .\n';
+    const rules = 'rdf(S, iri("https://example/ancestor"), O, G) :- rdf(S, iri("https://example/parent"), O, G).';
+    const output = run(compileRdfToEyeProlog(input, { rules }), { goal: 'rdf(S, P, O, G)' }).stdout;
+    equal(extractEyePrologRdf(output), '<https://example/s> <https://example/ancestor> <https://example/o> .\n');
+  });
+  reporter.test('RDF 1.2 terms survive an include-source round trip', () => {
+    const input = 'VERSION "1.2"\n<https://example/s> <https://example/says> <<( _:a <https://example/text> "مرحبا"@ar--rtl )>> .\n';
+    const output = run(compileRdfToEyeProlog(input, { scope: 'doc', includeSource: true }), { goal: 'rdf(S, P, O, G)' }).stdout;
+    equal(extractEyePrologRdf(output), '<https://example/s> <https://example/says> <<( _:e646f63_61 <https://example/text> "مرحبا"@ar--rtl )>> .\n');
+  });
+  reporter.test('nested RDF 1.2 triple terms survive a round trip', () => {
+    const input = '<https://example/s> <https://example/p> <<( <https://example/a> <https://example/b> <<( _:x <https://example/c> "line\\nfeed" )>> )>> .\n';
+    const output = run(compileRdfToEyeProlog(input, { scope: 'doc', includeSource: true }), { goal: 'rdf(S, P, O, G)' }).stdout;
+    equal(extractEyePrologRdf(output), '<https://example/s> <https://example/p> <<( <https://example/a> <https://example/b> <<( _:e646f63_78 <https://example/c> "line\\nfeed" )>> )>> .\n');
+  });
+  reporter.test('RDF blank-node labels accept the full Unicode production', () => {
+    const input = '_:éclair <https://example/p> _:名.\n';
+    const output = run(compileRdfToEyeProlog(input, { scope: 'doc', includeSource: true }), { goal: 'rdf(S, P, O, G)' }).stdout;
+    equal(extractEyePrologRdf(output), '_:e646f63_c3a9636c616972 <https://example/p> _:e646f63_e5908d .\n');
+  });
+  const generatedFixtures = [
+    ['RDF 1.2 annotation example', 'rdf12-annotation', 'rdf12-annotation'],
+    ['RDF 1.2 annotated claim resolution example', 'rdf12-annotated-claims', 'rdf12-annotated-claims'],
+    ['ODRL Turtle policy example', 'odrl-policy-from-turtle', 'odrl-policy'],
+    ['advanced ODRL Turtle policy example', 'odrl-policy-advanced-from-turtle', 'odrl-policy-advanced'],
+    ['ODRL-DPV-FPV trust-flow example', 'odrl-dpv-fpv-trust-flow', 'odrl-dpv-fpv-trust-flow'],
+    ['healthcare ODRL-DPV risk example', 'odrl-dpv-healthcare-risk-ranked', 'odrl-dpv-healthcare-risk-ranked'],
+    ['consumer ODRL-DPV risk example', 'odrl-dpv-risk-ranked', 'odrl-dpv-risk-ranked'],
+    ['DPV-ODRL purpose mapping example', 'dpv-odrl-purpose-mapping', 'dpv-odrl-purpose-mapping'],
+  ];
+  for (const [label, programStem, inputStem] of generatedFixtures) {
+    const source = await fs.readFile(new URL(`../examples/input/${inputStem}.ttl`, import.meta.url), 'utf8');
+    const rules = await fs.readFile(new URL(`../examples/input/${inputStem}-rules.pl`, import.meta.url), 'utf8');
+    const generated = await compileRdfDocumentToEyeProlog(source, {
+      inputPath: `${inputStem}.ttl`,
+      scope: `${inputStem}.ttl`,
+      rules,
+    });
+    const committed = await fs.readFile(new URL(`../examples/${programStem}.pl`, import.meta.url), 'utf8');
+    reporter.test(`${label} is generated from its input fixture`, () => {
+      equal(generated, committed);
+    });
+  }
+  const documents = [
+    ['Turtle 1.2', 'example.ttl', '@prefix ex: <https://example/>. ex:s ex:p <<( ex:a ex:b "hello"@en--ltr )>>.'],
+    ['TriG 1.2', 'example.trig', '@prefix ex: <https://example/>. ex:g { ex:s ex:p ex:o }'],
+    ['JSON-LD', 'example.jsonld', JSON.stringify({ '@context': { ex: 'https://example/' }, '@id': 'ex:s', 'ex:p': { '@id': 'ex:o' } })],
+    ['RDF/XML 1.2', 'example.rdf', '<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:ex="https://example/"><rdf:Description rdf:about="https://example/s"><ex:p rdf:resource="https://example/o"/></rdf:Description></rdf:RDF>'],
+    ['RDFa', 'example.html', '<div prefix="ex: https://example/" about="ex:s"><a property="ex:p" href="https://example/o">o</a></div>'],
+  ];
+  for (const [name, inputPath, source] of documents) {
+    const program = await compileRdfDocumentToEyeProlog(source, { inputPath, includeSource: true, scope: inputPath, baseIRI: 'https://example/base' });
+    const output = extractEyePrologRdf(run(program, { goal: 'rdf(S, P, O, G)' }).stdout);
+    reporter.test(`${name} input is accepted`, () => { if (!output) throw new Error('expected at least one RDF quad'); });
+  }
+  reporter.sectionTotal('RDF tool');
+}
+function equal(a, e) { if (a !== e) throw new Error(`expected ${JSON.stringify(e)}\nactual   ${JSON.stringify(a)}`); }
+if (isMainModule(import.meta.url)) { const r = new TestReporter(); try { await runRdfTools(r); r.totalLine(); } catch (_) { process.exit(1); } }