eyeling 1.26.6 → 1.27.0

package/lib/cli.js

@@ -7,12 +7,15 @@
 
 'use strict';
 
+const fs = require('node:fs');
 const path = require('node:path');
-const { pathToFileURL } = require('node:url');
+const { pathToFileURL, fileURLToPath } = require('node:url');
+const { TextDecoder } = require('node:util');
 
 const engine = require('./engine');
 const deref = require('./deref');
 const { PrefixEnv } = require('./prelude');
+const { normalizeRdfCompatibility } = require('./lexer');
 const { parseN3Text, mergeParsedDocuments } = require('./multisource');
 
 function offsetToLineCol(text, offset) {
@@ -51,7 +54,6 @@ function formatN3SyntaxError(err, text, path) {
 
 // CLI entry point (invoked when eyeling.js is run directly)
 function readTextFromStdinSync() {
-  const fs = require('node:fs');
   return fs.readFileSync(0, { encoding: 'utf8' });
 }
 
@@ -74,10 +76,374 @@ function __readInputSourceSync(sourceLabel) {
     return txt;
   }
 
-  const fs = require('node:fs');
   return fs.readFileSync(sourceLabel, { encoding: 'utf8' });
 }
 
+
+const RDF_MESSAGE_VERSION_RE = /^\s*(?:@version|VERSION)\s+(["'])(?:1\.1|1\.2|1\.2-basic)-messages\1\s*\.?\s*(?:#.*)?$/im;
+const RDF_MESSAGE_VERSION_LINE_RE = /^\s*(?:@version|VERSION)\s+(["'])(?:1\.1|1\.2|1\.2-basic)-messages\1\s*\.?\s*(?:#.*)?$/i;
+const RDF_DIRECTIVE_LINE_RE = /^\s*(?:@?(?:prefix|base)\b|PREFIX\b|BASE\b)/i;
+const RDF_MESSAGE_DELIMITER_LINE_RE = /^\s*(?:MESSAGE\b|@message\s*\.?)\s*(?:#.*)?$/i;
+const LOG_NAME_OF_IRI = '<http://www.w3.org/2000/10/swap/log#nameOf>';
+const RDF_TYPE_IRI = '<http://www.w3.org/1999/02/22-rdf-syntax-ns#type>';
+const XSD_INTEGER_IRI = '<http://www.w3.org/2001/XMLSchema#integer>';
+const EYMSG_NS = 'https://eyereasoner.github.io/eyeling/vocab/message#';
+const EYMSG_IRIS = Object.freeze({
+  RDFMessageStream: `<${EYMSG_NS}RDFMessageStream>`,
+  MessageEnvelope: `<${EYMSG_NS}MessageEnvelope>`,
+  envelope: `<${EYMSG_NS}envelope>`,
+  firstEnvelope: `<${EYMSG_NS}firstEnvelope>`,
+  lastEnvelope: `<${EYMSG_NS}lastEnvelope>`,
+  orderedEnvelopes: `<${EYMSG_NS}orderedEnvelopes>`,
+  offset: `<${EYMSG_NS}offset>`,
+  payloadGraph: `<${EYMSG_NS}payloadGraph>`,
+  payloadKind: `<${EYMSG_NS}payloadKind>`,
+  empty: `<${EYMSG_NS}empty>`,
+  nonEmpty: `<${EYMSG_NS}nonEmpty>`,
+});
+
+function simpleHashText(s) {
+  let h = 0x811c9dc5;
+  const text = String(s || '');
+  for (let i = 0; i < text.length; i += 1) {
+    h ^= text.charCodeAt(i);
+    h = Math.imul(h, 0x01000193) >>> 0;
+  }
+  return h.toString(16).padStart(8, '0');
+}
+
+function __isLocalPathSource(sourceLabel) {
+  return typeof sourceLabel === 'string' && sourceLabel !== '<stdin>' && !/^(https?:|file:\/\/)/i.test(sourceLabel);
+}
+
+function __localPathForSource(sourceLabel) {
+  if (__isLocalPathSource(sourceLabel)) return sourceLabel;
+  if (typeof sourceLabel === 'string' && /^file:\/\//i.test(sourceLabel)) return fileURLToPath(sourceLabel);
+  return null;
+}
+
+function __sourceLooksLikeRdfMessageLogSync(sourceLabel) {
+  const filePath = __localPathForSource(sourceLabel);
+  if (filePath) {
+    const fd = fs.openSync(filePath, 'r');
+    try {
+      const buf = Buffer.allocUnsafe(64 * 1024);
+      const n = fs.readSync(fd, buf, 0, buf.length, 0);
+      return RDF_MESSAGE_VERSION_RE.test(buf.toString('utf8', 0, n));
+    } finally {
+      fs.closeSync(fd);
+    }
+  }
+  return RDF_MESSAGE_VERSION_RE.test(__readInputSourceSync(sourceLabel));
+}
+
+function stripRdfDirectiveLines(text) {
+  return String(text || '')
+    .split(/(?<=\r\n|\n|\r)/)
+    .filter((line) => !RDF_DIRECTIVE_LINE_RE.test(line) && !RDF_MESSAGE_VERSION_LINE_RE.test(line))
+    .join('');
+}
+
+function hasRdfPayload(text) {
+  return String(text || '')
+    .split(/\r\n|\n|\r/)
+    .some((line) => {
+      const trimmed = line.replace(/#.*$/g, '').trim();
+      return trimmed && !RDF_DIRECTIVE_LINE_RE.test(trimmed) && !RDF_MESSAGE_VERSION_LINE_RE.test(trimmed);
+    });
+}
+
+function addRdfDirective(directives, seen, line) {
+  if (!RDF_DIRECTIVE_LINE_RE.test(line)) return;
+  const key = line.trim();
+  if (!key || seen.has(key)) return;
+  seen.add(key);
+  directives.push(line.endsWith('\n') || line.endsWith('\r') ? line : line + '\n');
+}
+
+function normalizeStreamingPayloadChunk(chunk, directives) {
+  const prelude = directives.join('');
+  const normalized = normalizeRdfCompatibility(prelude + String(chunk || ''));
+  return stripRdfDirectiveLines(normalized).trim();
+}
+
+function buildSingleMessageReplayDocument({ sourceLabel, messageIndex, chunk, directives }) {
+  const hash = simpleHashText(sourceLabel || '<stream>');
+  const base = `urn:eyeling:message-stream:${hash}`;
+  const padded = String(messageIndex).padStart(6, '0');
+  const stream = `<${base}#stream>`;
+  const envelope = `<${base}#m${padded}>`;
+  const payload = `<${base}#m${padded}/payload>`;
+  const body = normalizeStreamingPayloadChunk(chunk, directives);
+  const hasBody = hasRdfPayload(body);
+  const out = [];
+
+  out.push(...directives.map((line) => line.trim()).filter(Boolean));
+  out.push(`${stream} ${RDF_TYPE_IRI} ${EYMSG_IRIS.RDFMessageStream} .`);
+  out.push(`${stream} ${EYMSG_IRIS.envelope} ${envelope} .`);
+  out.push(`${stream} ${EYMSG_IRIS.orderedEnvelopes} (${envelope}) .`);
+  out.push(`${stream} ${EYMSG_IRIS.firstEnvelope} ${envelope} .`);
+  out.push(`${stream} ${EYMSG_IRIS.lastEnvelope} ${envelope} .`);
+  out.push(`${envelope} ${RDF_TYPE_IRI} ${EYMSG_IRIS.MessageEnvelope} .`);
+  out.push(`${envelope} ${EYMSG_IRIS.offset} "${messageIndex}"^^${XSD_INTEGER_IRI} .`);
+  out.push(`${envelope} ${EYMSG_IRIS.payloadKind} ${hasBody ? EYMSG_IRIS.nonEmpty : EYMSG_IRIS.empty} .`);
+  if (hasBody) {
+    out.push(`${envelope} ${EYMSG_IRIS.payloadGraph} ${payload} .`);
+    out.push(`${payload} ${LOG_NAME_OF_IRI} {`);
+    out.push(body);
+    out.push(`} .`);
+  }
+  return out.join('\n') + '\n';
+}
+
+function forEachRdfMessageChunkInText(text, onMessage) {
+  const directives = [];
+  const seenDirectives = new Set();
+  let chunk = '';
+  let messageIndex = 1;
+  let sawVersion = false;
+  let sawDelimiter = false;
+
+  function emit() {
+    onMessage({ messageIndex, chunk, directives: directives.slice() });
+    messageIndex += 1;
+    chunk = '';
+  }
+
+  const lines = String(text || '').match(/.*(?:\r\n|\n|\r)|.+$/g) || [];
+  for (const line of lines) {
+    if (RDF_MESSAGE_VERSION_LINE_RE.test(line)) {
+      sawVersion = true;
+      continue;
+    }
+    if (RDF_MESSAGE_DELIMITER_LINE_RE.test(line)) {
+      emit();
+      sawDelimiter = true;
+      continue;
+    }
+    addRdfDirective(directives, seenDirectives, line);
+    chunk += line;
+  }
+  if (!sawVersion) throw new Error('not an RDF Message Log: missing VERSION "*-messages" directive');
+  if (sawDelimiter || hasRdfPayload(chunk)) emit();
+}
+
+function forEachLineInFileSync(filePath, onLine) {
+  const fd = fs.openSync(filePath, 'r');
+  const decoder = new TextDecoder('utf8');
+  const buf = Buffer.allocUnsafe(64 * 1024);
+  let carry = '';
+  try {
+    for (;;) {
+      const n = fs.readSync(fd, buf, 0, buf.length, null);
+      if (n === 0) break;
+      carry += decoder.decode(buf.subarray(0, n), { stream: true });
+      for (;;) {
+        const m = /\r\n|\n|\r/.exec(carry);
+        if (!m) break;
+        const end = m.index + m[0].length;
+        onLine(carry.slice(0, end));
+        carry = carry.slice(end);
+      }
+    }
+    carry += decoder.decode();
+    if (carry) onLine(carry);
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+function forEachRdfMessageChunkInFileSync(filePath, onMessage) {
+  const directives = [];
+  const seenDirectives = new Set();
+  let chunk = '';
+  let messageIndex = 1;
+  let sawVersion = false;
+  let sawDelimiter = false;
+
+  function emit() {
+    onMessage({ messageIndex, chunk, directives: directives.slice() });
+    messageIndex += 1;
+    chunk = '';
+  }
+
+  forEachLineInFileSync(filePath, (line) => {
+    if (RDF_MESSAGE_VERSION_LINE_RE.test(line)) {
+      sawVersion = true;
+      return;
+    }
+    if (RDF_MESSAGE_DELIMITER_LINE_RE.test(line)) {
+      emit();
+      sawDelimiter = true;
+      return;
+    }
+    addRdfDirective(directives, seenDirectives, line);
+    chunk += line;
+  });
+
+  if (!sawVersion) throw new Error('not an RDF Message Log: missing VERSION "*-messages" directive');
+  if (sawDelimiter || hasRdfPayload(chunk)) emit();
+}
+
+
+function __forEachRdfMessageChunkSync(sourceLabel, onMessage) {
+  const filePath = __localPathForSource(sourceLabel);
+  if (filePath) {
+    forEachRdfMessageChunkInFileSync(filePath, onMessage);
+    return;
+  }
+  forEachRdfMessageChunkInText(__readInputSourceSync(sourceLabel), onMessage);
+}
+
+function factsContainOutputStrings(triplesForOutput) {
+  const LOG_OUTPUT_STRING = 'http://www.w3.org/2000/10/swap/log#outputString';
+  return (
+    Array.isArray(triplesForOutput) &&
+    triplesForOutput.some(
+      (tr) => tr && tr.p && tr.p.constructor && tr.p.constructor.name === 'Iri' && tr.p.value === LOG_OUTPUT_STRING,
+    )
+  );
+}
+
+function programMayProduceOutputStrings(topLevelTriples, forwardRules, logQueryRules) {
+  const hasOutputStringPredicate = (trs) => factsContainOutputStrings(trs);
+  if (hasOutputStringPredicate(topLevelTriples)) return true;
+  if (Array.isArray(forwardRules) && forwardRules.some((r) => hasOutputStringPredicate(r && r.conclusion))) return true;
+  if (Array.isArray(logQueryRules) && logQueryRules.some((r) => hasOutputStringPredicate(r && r.conclusion))) return true;
+  return false;
+}
+
+function runParsedDocumentOnce(mergedDocument, { rdfMode = false, outputPrefixes = null } = {}) {
+  const prefixes = mergedDocument.prefixes;
+  const triples = mergedDocument.triples;
+  const frules = mergedDocument.frules;
+  const brules = mergedDocument.brules;
+  const qrules = mergedDocument.logQueryRules;
+
+  engine.materializeRdfLists(triples, frules.concat(qrules || []), brules);
+  const facts = triples.slice();
+  const hasQueries = Array.isArray(qrules) && qrules.length;
+  const mayAutoRenderOutputStrings = programMayProduceOutputStrings(triples, frules, qrules);
+
+  let derived = [];
+  let outTriples = [];
+  if (hasQueries) {
+    const res = engine.forwardChainAndCollectLogQueryConclusions(facts, frules, brules, qrules, { prefixes });
+    derived = res.derived;
+    outTriples = res.queryTriples;
+  } else {
+    const skipDerivedCollection = mayAutoRenderOutputStrings;
+    derived = engine.forwardChain(facts, frules, brules, null, {
+      captureExplanations: false,
+      collectDerived: !skipDerivedCollection,
+      prefixes,
+    });
+    outTriples = skipDerivedCollection ? [] : derived.map((df) => df.fact);
+  }
+
+  const renderedOutputTriples = hasQueries ? outTriples : facts;
+  if (factsContainOutputStrings(renderedOutputTriples)) {
+    process.stdout.write(engine.collectOutputStringsFromFacts(renderedOutputTriples, prefixes));
+    return;
+  }
+
+  const outPrefixEnv = outputPrefixes || prefixes;
+  if (rdfMode) {
+    for (const tr of outTriples) console.log(engine.tripleToRdfCompatible(tr, outPrefixEnv));
+  } else if (hasQueries) {
+    const bodyText = engine.prettyPrintQueryTriples(outTriples, outPrefixEnv);
+    if (bodyText) process.stdout.write(String(bodyText).replace(/\s*$/g, '') + '\n');
+  } else {
+    for (const df of derived) console.log(engine.tripleToN3(df.fact, outPrefixEnv));
+  }
+}
+
+function runStreamMessagesMode(sourceLabels, { rdfMode }) {
+  const ordinarySourceLabels = [];
+  const messageSourceLabels = [];
+
+  for (const sourceLabel of sourceLabels) {
+    try {
+      if (__sourceLooksLikeRdfMessageLogSync(sourceLabel)) messageSourceLabels.push(sourceLabel);
+      else ordinarySourceLabels.push(sourceLabel);
+    } catch (e) {
+      console.error(`Error reading source ${JSON.stringify(sourceLabel)}: ${e && e.message ? e.message : String(e)}`);
+      process.exit(1);
+    }
+  }
+
+  if (!messageSourceLabels.length) {
+    console.error('Error: --stream-messages did not find any RDF Message Log input.');
+    process.exit(1);
+  }
+
+  const programSources = [];
+  for (const sourceLabel of ordinarySourceLabels) {
+    let text;
+    try {
+      text = __readInputSourceSync(sourceLabel);
+    } catch (e) {
+      if (sourceLabel === '<stdin>') console.error(`Error reading stdin: ${e.message}`);
+      else console.error(`Error reading source ${JSON.stringify(sourceLabel)}: ${e.message}`);
+      process.exit(1);
+    }
+
+    try {
+      programSources.push(
+        parseN3Text(text, {
+          baseIri: __sourceLabelToBaseIri(sourceLabel),
+          label: sourceLabel,
+          keepSourceArtifacts: false,
+          sourceLocations: false,
+          rdf: rdfMode,
+        }),
+      );
+    } catch (e) {
+      if (e && e.name === 'N3SyntaxError') {
+        console.error(formatN3SyntaxError(e, text, sourceLabel));
+        process.exit(1);
+      }
+      throw e;
+    }
+  }
+
+  const fullIriPrefixes = new PrefixEnv({});
+  for (const messageSourceLabel of messageSourceLabels) {
+    try {
+      __forEachRdfMessageChunkSync(messageSourceLabel, ({ messageIndex, chunk, directives }) => {
+        const messageText = buildSingleMessageReplayDocument({
+          sourceLabel: messageSourceLabel,
+          messageIndex,
+          chunk,
+          directives,
+        });
+        let messageDoc;
+        try {
+          messageDoc = parseN3Text(messageText, {
+            baseIri: `${__sourceLabelToBaseIri(messageSourceLabel)}#message-${messageIndex}`,
+            label: `${messageSourceLabel}#message-${messageIndex}`,
+            keepSourceArtifacts: false,
+            sourceLocations: false,
+            rdf: false,
+          });
+        } catch (e) {
+          if (e && e.name === 'N3SyntaxError') {
+            console.error(formatN3SyntaxError(e, messageText, `${messageSourceLabel}#message-${messageIndex}`));
+            process.exit(1);
+          }
+          throw e;
+        }
+
+        const merged = mergeParsedDocuments(programSources.concat([messageDoc]));
+        runParsedDocumentOnce(merged, { rdfMode, outputPrefixes: fullIriPrefixes });
+      });
+    } catch (e) {
+      console.error(`Error streaming RDF Message Log ${JSON.stringify(messageSourceLabel)}: ${e && e.message ? e.message : String(e)}`);
+      process.exit(1);
+    }
+  }
+}
+
 function main() {
   // Drop "node" and script name; keep only user-provided args
   // Expand combined short options: -pt == -p -t
@@ -108,6 +474,7 @@ function main() {
       `  -h, --help                   Show this help and exit.\n` +
       `  -p, --proof                  Enable proof explanations.\n` +
       `  -r, --rdf                    Enable RDF/TriG input/output compatibility.\n` +
+      `      --stream-messages        Process RDF Message Logs one message at a time under -r.\n` +
       `  -s, --super-restricted       Disable all builtins except => and <=.\n` +
       `  -t, --stream                 Stream derived triples as soon as they are derived.\n` +
       `  -v, --version                Print version and exit.\n`;
@@ -149,6 +516,7 @@ function main() {
 
   const showAst = argv.includes('--ast') || argv.includes('-a');
   const streamMode = argv.includes('--stream') || argv.includes('-t');
+  const streamMessagesMode = argv.includes('--stream-messages');
   const rdfMode = argv.includes('--rdf') || argv.includes('-r');
 
   // --enforce-https: rewrite http:// -> https:// for log dereferencing builtins
@@ -171,6 +539,26 @@ function main() {
     if (typeof engine.setSuperRestrictedMode === 'function') engine.setSuperRestrictedMode(true);
   }
 
+
+  if (streamMessagesMode) {
+    if (!rdfMode) {
+      console.error('Error: --stream-messages requires -r/--rdf.');
+      process.exit(1);
+    }
+    if (showAst) {
+      console.error('Error: --stream-messages cannot be combined with --ast.');
+      process.exit(1);
+    }
+    if (streamMode) {
+      console.error('Error: --stream-messages cannot be combined with --stream.');
+      process.exit(1);
+    }
+    if (engine.getProofCommentsEnabled()) {
+      console.error('Error: --stream-messages currently does not support proof output.');
+      process.exit(1);
+    }
+  }
+
   // Positional args (one or more N3 sources).
   const useImplicitStdin = positional.length === 0 && !process.stdin.isTTY;
   if (positional.length === 0 && !useImplicitStdin) {
@@ -194,6 +582,11 @@ function main() {
     process.exit(1);
   }
 
+  if (streamMessagesMode) {
+    runStreamMessagesMode(sourceLabels, { rdfMode });
+    return;
+  }
+
   const parsedSources = [];
   for (const sourceLabel of sourceLabels) {
     let text;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyeling",
-  "version": "1.26.6",
+  "version": "1.27.0",
   "description": "A minimal Notation3 (N3) reasoner in JavaScript.",
   "main": "./index.js",
   "keywords": [
@@ -40,14 +40,16 @@
     "prebuild": "eslint . --fix",
     "build": "node tools/bundle.js",
     "test:packlist": "node test/packlist.test.js",
-    "test:api": "node test/api.test.js",
+    "test:api": "node test/api.test.js && node test/stream_messages.test.js",
+    "test:stream-messages": "node test/stream_messages.test.js",
     "test:builtins": "node test/builtins.test.js",
     "test:examples": "node test/examples.test.js",
+    "test:examples:proof": "node test/examples.test.js --proof-only",
     "test:manifest": "node test/manifest.test.js",
     "test:playground": "node test/playground.test.js",
     "test:package": "node test/package.test.js",
     "pretest": "npm run build && npm run test:packlist",
-    "test": "npm run test:api && npm run test:builtins && npm run test:examples && npm run test:manifest && npm run test:playground",
+    "test": "npm run test:api && npm run test:builtins && npm run test:examples && npm run test:examples:proof && npm run test:manifest && npm run test:playground",
     "posttest": "npm run test:package",
     "preversion": "npm test",
     "postversion": "git push origin HEAD --follow-tags"

package/test/examples.test.js

@@ -212,6 +212,8 @@ function runExampleToFile({ root, examplesDir, eyelingJsPath, nodePath, file, ge
 
 function main() {
   const suiteStart = Date.now();
+  const proofOnly = process.argv.includes('--proof-only');
+
 
   // test/examples.test.js -> repo root is one level up
   const root = path.resolve(__dirname, '..');
@@ -230,11 +232,13 @@ function main() {
     process.exit(1);
   }
 
-  const files = fs
-    .readdirSync(examplesDir)
-    .filter((f) => f.endsWith('.n3'))
-    .sort((a, b) => a.localeCompare(b));
-  const proofFiles = fs.existsSync(proofDir)
+  const files = proofOnly
+    ? []
+    : fs
+        .readdirSync(examplesDir)
+        .filter((f) => f.endsWith('.n3'))
+        .sort((a, b) => a.localeCompare(b));
+  const proofFiles = proofOnly && fs.existsSync(proofDir)
     ? fs
         .readdirSync(proofDir)
         .filter((f) => f.endsWith('.n3') && fs.existsSync(path.join(examplesDir, f)))
@@ -242,11 +246,13 @@ function main() {
     : [];
   const totalTests = files.length + proofFiles.length;
 
-  info(`Running ${files.length} examples tests and ${proofFiles.length} proof golden tests`);
+  info(proofOnly
+    ? `Running ${proofFiles.length} proof golden tests`
+    : `Running ${files.length} examples tests`);
   console.log(`${C.dim}${getEyelingVersion(nodePath, eyelingJsPath, root)}; node ${process.version}${C.n}`);
 
-  if (files.length === 0) {
-    ok('No .n3 files found in examples/');
+  if (totalTests === 0) {
+    ok(proofOnly ? 'No proof goldens found in examples/proof/' : 'No .n3 files found in examples/');
     process.exit(0);
   }
 
@@ -256,6 +262,7 @@ function main() {
   // Pretty, stable numbering (e.g., 001..100 when running 100 tests)
   const idxWidth = String(files.length).length;
   const proofIdxWidth = String(Math.max(proofFiles.length, 1)).length;
+  const proofLabel = proofOnly ? '' : 'proof ';
 
   for (let i = 0; i < files.length; i++) {
     const idx = String(i + 1).padStart(idxWidth, '0');
@@ -357,7 +364,7 @@ function main() {
       n3Text = fs.readFileSync(filePath, 'utf8');
     } catch (e) {
       const ms = Date.now() - start;
-      fail(`proof ${idx} ${file} ${msTag(ms)}`);
+      fail(`${proofLabel}${idx} ${file} ${msTag(ms)}`);
       fail(`Cannot read proof input: ${e.message}`);
       failed++;
       continue;
@@ -381,13 +388,13 @@ function main() {
 
     if (diffOk && rcOk) {
       if (expectedRc === 0) {
-        ok(`proof ${idx} ${file} ${msTag(ms)}`);
+        ok(`${proofLabel}${idx} ${file} ${msTag(ms)}`);
       } else {
-        ok(`proof ${idx} ${file} (expected exit ${expectedRc}) ${msTag(ms)}`);
+        ok(`${proofLabel}${idx} ${file} (expected exit ${expectedRc}) ${msTag(ms)}`);
       }
       passed++;
     } else {
-      fail(`proof ${idx} ${file} ${msTag(ms)}`);
+      fail(`${proofLabel}${idx} ${file} ${msTag(ms)}`);
       if (!rcOk) {
         fail(`Exit code ${rc}, expected ${expectedRc}`);
       }
@@ -410,10 +417,14 @@ function main() {
   info(`Total elapsed: ${suiteMs} ms (${(suiteMs / 1000).toFixed(2)} s)`);
 
   if (failed === 0) {
-    ok(`All examples tests passed (${passed}/${totalTests})`);
+    ok(proofOnly
+      ? `All proof golden tests passed (${passed}/${totalTests})`
+      : `All examples tests passed (${passed}/${totalTests})`);
     process.exit(0);
   } else {
-    fail(`Some examples tests failed (${passed}/${totalTests})`);
+    fail(proofOnly
+      ? `Some proof golden tests failed (${passed}/${totalTests})`
+      : `Some examples tests failed (${passed}/${totalTests})`);
     // keep exit code 2 (matches historical behavior of examples/test)
     process.exit(2);
   }