eyeling 1.28.9 → 1.29.1

package/index.d.ts

@@ -151,6 +151,14 @@ declare module 'eyeling' {
     document?: EyelingAstBundle;
   }
 
+  export interface StoreOptions {
+    name?: string;
+    clear?: boolean;
+    path?: string;
+    type?: 'memory' | 'persistent';
+    backend?: 'memory' | 'level' | 'indexeddb';
+  }
+
   export interface ReasonOptions {
     proof?: boolean;
     proofComments?: boolean;
@@ -158,6 +166,9 @@ declare module 'eyeling' {
     args?: string[];
     maxBuffer?: number;
     builtinModules?: string | string[];
+    store?: string | StoreOptions;
+    storePath?: string;
+    storeClear?: boolean;
   }
 
   export interface BuiltinRegistrationContext {
@@ -183,6 +194,9 @@ declare module 'eyeling' {
     dataFactory?: RdfJsDataFactory | null;
     skipUnsupportedRdfJs?: boolean;
     builtinModules?: string | string[];
+    store?: string | StoreOptions;
+    storePath?: string;
+    storeClear?: boolean;
     onDerived?: (item: { triple: string; quad?: RdfJsQuad; quads?: RdfJsQuad[]; df: any }) => void;
   }
 
@@ -198,10 +212,45 @@ declare module 'eyeling' {
     queryQuads?: RdfJsQuad[];
   }
 
+  export interface FactStore {
+    add(triple: EyelingTriple, kind?: 'explicit' | 'inferred'): Promise<boolean>;
+    has(triple: EyelingTriple): Promise<boolean>;
+    kindOf?(triple: EyelingTriple): Promise<number>;
+    match(s?: EyelingTerm | null, p?: EyelingTerm | null, o?: EyelingTerm | null): AsyncIterable<EyelingTriple>;
+    batchAdd?(triples: Iterable<EyelingTriple>, kind?: 'explicit' | 'inferred'): Promise<number>;
+    clear?(): Promise<void>;
+    close?(): Promise<void>;
+  }
+
+  export class MemoryFactStore implements FactStore {
+    constructor();
+    add(triple: EyelingTriple, kind?: 'explicit' | 'inferred'): Promise<boolean>;
+    has(triple: EyelingTriple): Promise<boolean>;
+    kindOf(triple: EyelingTriple): Promise<number>;
+    match(s?: EyelingTerm | null, p?: EyelingTerm | null, o?: EyelingTerm | null): AsyncIterable<EyelingTriple>;
+    batchAdd(triples: Iterable<EyelingTriple>, kind?: 'explicit' | 'inferred'): Promise<number>;
+    clear(): Promise<void>;
+    close(): Promise<void>;
+  }
+
+  export class PersistentFactStore implements FactStore {
+    add(triple: EyelingTriple, kind?: 'explicit' | 'inferred'): Promise<boolean>;
+    has(triple: EyelingTriple): Promise<boolean>;
+    kindOf(triple: EyelingTriple): Promise<number>;
+    match(s?: EyelingTerm | null, p?: EyelingTerm | null, o?: EyelingTerm | null): AsyncIterable<EyelingTriple>;
+    batchAdd(triples: Iterable<EyelingTriple>, kind?: 'explicit' | 'inferred'): Promise<number>;
+    clear(): Promise<void>;
+    close(): Promise<void>;
+  }
+
   export function reason(
     opts: ReasonOptions,
     input: string | RdfJsReasonInput | EyelingAstBundle | N3SourceListInput,
   ): string;
+  export function runAsync(
+    input: string | RdfJsReasonInput | EyelingAstBundle | N3SourceListInput,
+    opts?: ReasonStreamOptions,
+  ): Promise<ReasonStreamResult & { store?: FactStore }>;
   export function reasonStream(
     input: string | RdfJsReasonInput | EyelingAstBundle | N3SourceListInput,
     opts?: ReasonStreamOptions,
@@ -213,6 +262,7 @@ declare module 'eyeling' {
 
   export const INFERENCE_FUSE_EXIT_CODE: 65;
   export const rdfjs: RdfJsDataFactory;
+  export function createFactStore(options?: string | StoreOptions | null): Promise<FactStore>;
   export function registerBuiltin(iri: string, handler: BuiltinHandler): BuiltinHandler;
   export function unregisterBuiltin(iri: string): boolean;
   export function registerBuiltinModule(mod: any, origin?: string): boolean;
@@ -230,7 +280,13 @@ declare module 'eyeling/browser' {
   export type ReasonStreamOptions = import('eyeling').ReasonStreamOptions;
   export type ReasonStreamResult = import('eyeling').ReasonStreamResult;
   export type BuiltinHandler = import('eyeling').BuiltinHandler;
+  export type StoreOptions = import('eyeling').StoreOptions;
+  export type FactStore = import('eyeling').FactStore;
 
+  export function runAsync(
+    input: string | RdfJsReasonInput | EyelingAstBundle | N3SourceListInput,
+    opts?: ReasonStreamOptions,
+  ): Promise<ReasonStreamResult & { store?: FactStore }>;
   export function reasonStream(
     input: string | RdfJsReasonInput | EyelingAstBundle | N3SourceListInput,
     opts?: ReasonStreamOptions,
@@ -242,6 +298,7 @@ declare module 'eyeling/browser' {
 
   export const INFERENCE_FUSE_EXIT_CODE: 65;
   export const rdfjs: RdfJsDataFactory;
+  export function createFactStore(options?: string | StoreOptions | null): Promise<FactStore>;
   export function registerBuiltin(iri: string, handler: BuiltinHandler): BuiltinHandler;
   export function unregisterBuiltin(iri: string): boolean;
   export function registerBuiltinModule(mod: any, origin?: string): boolean;
@@ -249,10 +306,12 @@ declare module 'eyeling/browser' {
 
   const eyeling: {
     readonly version: string;
+    runAsync: typeof runAsync;
     reasonStream: typeof reasonStream;
     reasonRdfJs: typeof reasonRdfJs;
     readonly INFERENCE_FUSE_EXIT_CODE: typeof INFERENCE_FUSE_EXIT_CODE;
     rdfjs: typeof rdfjs;
+    createFactStore: typeof createFactStore;
     registerBuiltin: typeof registerBuiltin;
     unregisterBuiltin: typeof unregisterBuiltin;
     registerBuiltinModule: typeof registerBuiltinModule;

package/index.js

@@ -42,6 +42,15 @@ function reason(opt = {}, input = '') {
 
   if (opt.rdf) args.push('--rdf');
 
+  if (typeof opt.store === 'string' && opt.store) args.push('--store', opt.store);
+  else if (opt.store && typeof opt.store === 'object') {
+    if (opt.store.name) args.push('--store', String(opt.store.name));
+    if (opt.store.clear) args.push('--store-clear');
+    if (opt.store.path) args.push('--store-path', String(opt.store.path));
+  }
+  if (opt.storePath) args.push('--store-path', String(opt.storePath));
+  if (opt.storeClear) args.push('--store-clear');
+
   if (Array.isArray(opt.args)) args.push(...opt.args);
 
   const builtinModules = Array.isArray(opt.builtinModules)
@@ -106,8 +115,13 @@ function reason(opt = {}, input = '') {
   }
 }
 
+async function runAsync(input = '', opt = {}) {
+  return engine.runAsync(input, opt || {});
+}
+
 module.exports = {
   reason,
+  runAsync,
   reasonStream: bundleApi.reasonStream,
   reasonRdfJs: bundleApi.reasonRdfJs,
   rdfjs: dataFactory,
@@ -116,6 +130,9 @@ module.exports = {
   registerBuiltinModule: engine.registerBuiltinModule,
   loadBuiltinModule: engine.loadBuiltinModule,
   listBuiltinIris: engine.listBuiltinIris,
+  createFactStore: engine.createFactStore,
+  MemoryFactStore: engine.MemoryFactStore,
+  PersistentFactStore: engine.PersistentFactStore,
 };
 
 // small interop nicety for ESM default import

package/lib/cli.js

@@ -562,10 +562,12 @@ function runParsedDocumentOnce(mergedDocument, { rdfMode = false, outputPrefixes
 
   let derived = [];
   let outTriples = [];
+  let queryDerived = [];
   if (hasQueries) {
     const res = engine.forwardChainAndCollectLogQueryConclusions(facts, frules, brules, qrules, { prefixes });
     derived = res.derived;
     outTriples = res.queryTriples;
+    queryDerived = res.queryDerived || [];
   } else {
     const skipDerivedCollection = mayAutoRenderOutputStrings;
     derived = engine.forwardChain(facts, frules, brules, null, {
@@ -579,7 +581,7 @@ function runParsedDocumentOnce(mergedDocument, { rdfMode = false, outputPrefixes
   const renderedOutputTriples = hasQueries ? outTriples : facts;
   if (factsContainOutputStrings(renderedOutputTriples)) {
     process.stdout.write(engine.collectOutputStringsFromFacts(renderedOutputTriples, prefixes));
-    return;
+    return { facts, derived, outTriples, queryDerived, queryMode: !!hasQueries };
   }
 
   const outPrefixEnv = outputPrefixes || prefixes;
@@ -591,9 +593,99 @@ function runParsedDocumentOnce(mergedDocument, { rdfMode = false, outputPrefixes
   } else {
     for (const df of derived) console.log(engine.tripleToN3(df.fact, outPrefixEnv));
   }
+  return { facts, derived, outTriples, queryDerived, queryMode: !!hasQueries };
+}
+
+async function createCliStore({ storeName, storePath = null, storeClear = false } = {}) {
+  if (!storeName) return null;
+  return engine.createFactStore({ name: storeName, path: storePath || undefined, clear: !!storeClear });
+}
+
+async function persistRunResultToStore(store, runResult) {
+  if (!store || !runResult) return;
+  await store.batchAdd(runResult.facts || [], 'explicit');
+  await store.batchAdd((runResult.derived || []).map((df) => df.fact), 'inferred');
+  await store.batchAdd((runResult.queryDerived || []).map((df) => df.fact), 'inferred');
+  await store.batchAdd(runResult.outTriples || [], 'inferred');
+}
+
+function sourceLooksLikeLineBasedRdf(sourceLabel) {
+  if (typeof sourceLabel !== 'string') return false;
+  const clean = sourceLabel.split(/[?#]/, 1)[0].toLowerCase();
+  return /\.(?:nt|nq)(?:\.gz|\.br|\.deflate)?$/.test(clean);
+}
+
+function parseLineBasedRdfLine(line, { sourceLabel, lineNumber, rdfMode }) {
+  const text = String(line || '');
+  if (!text.trim() || /^\s*#/.test(text)) return [];
+  const doc = parseN3Text(text, {
+    baseIri: __sourceLabelToBaseIri(sourceLabel),
+    label: `${sourceLabel}:${lineNumber}`,
+    keepSourceArtifacts: false,
+    sourceLocations: false,
+    rdf: rdfMode,
+  });
+  return doc.triples || [];
 }
 
-async function runStreamMessagesMode(sourceLabels, { rdfMode }) {
+async function ingestLineBasedRdfSourceToStore(sourceLabel, store, { rdfMode = true } = {}) {
+  let lineNumber = 0;
+  let count = 0;
+  const onLine = async (line) => {
+    lineNumber += 1;
+    let triples;
+    try {
+      triples = parseLineBasedRdfLine(line, { sourceLabel, lineNumber, rdfMode });
+    } catch (e) {
+      if (e && e.name === 'N3SyntaxError') {
+        throw new Error(formatN3SyntaxError(e, line, `${sourceLabel}:${lineNumber}`));
+      }
+      throw e;
+    }
+    count += await store.batchAdd(triples, 'explicit');
+  };
+
+  const filePath = __localPathForSource(sourceLabel);
+  if (filePath) {
+    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;
+          await onLine(carry.slice(0, end));
+          carry = carry.slice(end);
+        }
+      }
+      carry += decoder.decode();
+      if (carry) await onLine(carry);
+    } finally {
+      fs.closeSync(fd);
+    }
+    return count;
+  }
+
+  if (__isHttpSource(sourceLabel)) {
+    const body = await __openHttpTextStream(sourceLabel);
+    const rl = readline.createInterface({ input: body, crlfDelay: Infinity });
+    for await (const line of rl) await onLine(line + '\n');
+    return count;
+  }
+
+  const text = __readInputSourceSync(sourceLabel);
+  for (const line of text.match(/.*(?:\r\n|\n|\r)|.+$/g) || []) await onLine(line);
+  return count;
+}
+
+
+async function runStreamMessagesMode(sourceLabels, { rdfMode, storeName = null, storePath = null, storeClear = false } = {}) {
   const ordinarySourceLabels = [];
   const messageSourceLabels = [];
 
@@ -642,40 +734,49 @@ async function runStreamMessagesMode(sourceLabels, { rdfMode }) {
     }
   }
 
+  const store = await createCliStore({ storeName, storePath, storeClear });
+  let pendingStoreWrites = Promise.resolve();
+
   const fullIriPrefixes = new PrefixEnv({});
-  for (const messageSourceLabel of messageSourceLabels) {
-    try {
-      await __forEachRdfMessageChunk(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,
+  try {
+    for (const messageSourceLabel of messageSourceLabels) {
+      try {
+        await __forEachRdfMessageChunk(messageSourceLabel, ({ messageIndex, chunk, directives }) => {
+          const messageText = buildSingleMessageReplayDocument({
+            sourceLabel: messageSourceLabel,
+            messageIndex,
+            chunk,
+            directives,
           });
-        } catch (e) {
-          if (e && e.name === 'N3SyntaxError') {
-            console.error(formatN3SyntaxError(e, messageText, `${messageSourceLabel}#message-${messageIndex}`));
-            process.exit(1);
+          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;
           }
-          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);
+          const merged = mergeParsedDocuments(programSources.concat([messageDoc]));
+          const result = runParsedDocumentOnce(merged, { rdfMode, outputPrefixes: fullIriPrefixes });
+          if (store) pendingStoreWrites = pendingStoreWrites.then(() => persistRunResultToStore(store, result));
+        });
+      } catch (e) {
+        console.error(`Error streaming RDF Message Log ${JSON.stringify(messageSourceLabel)}: ${e && e.message ? e.message : String(e)}`);
+        process.exit(1);
+      }
     }
+    await pendingStoreWrites;
+  } finally {
+    if (store && typeof store.close === 'function') await store.close();
   }
 }
 
@@ -710,6 +811,9 @@ async function main() {
       `  -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` +
+      `      --store <name>           Use an optional persistent fact store.\n` +
+      `      --store-clear            Clear the named store before this run.\n` +
+      `      --store-path <dir>       Node.js persistent store directory.\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`;
@@ -746,6 +850,35 @@ async function main() {
       builtinModules.push(a.slice('--builtin='.length));
       continue;
     }
+    if (a === '--store') {
+      const next = argv[i + 1];
+      if (!next || next.startsWith('-')) {
+        console.error('Error: --store expects a store name.');
+        process.exit(1);
+      }
+      argv.__storeName = next;
+      i += 1;
+      continue;
+    }
+    if (typeof a === 'string' && a.startsWith('--store=')) {
+      argv.__storeName = a.slice('--store='.length);
+      continue;
+    }
+    if (a === '--store-path') {
+      const next = argv[i + 1];
+      if (!next || next.startsWith('-')) {
+        console.error('Error: --store-path expects a directory path.');
+        process.exit(1);
+      }
+      argv.__storePath = next;
+      i += 1;
+      continue;
+    }
+    if (typeof a === 'string' && a.startsWith('--store-path=')) {
+      argv.__storePath = a.slice('--store-path='.length);
+      continue;
+    }
+    if (a === '--store-clear') continue;
     if (a === '-' || !a.startsWith('-')) positional.push(a);
   }
 
@@ -753,6 +886,9 @@ async function main() {
   const streamMode = argv.includes('--stream') || argv.includes('-t');
   const streamMessagesMode = argv.includes('--stream-messages');
   const rdfMode = argv.includes('--rdf') || argv.includes('-r');
+  const storeName = argv.__storeName || null;
+  const storePath = argv.__storePath || null;
+  const storeClear = argv.includes('--store-clear');
 
   // --enforce-https: rewrite http:// -> https:// for log dereferencing builtins
   if (argv.includes('--enforce-https') || argv.includes('-e')) {
@@ -811,17 +947,94 @@ async function main() {
     }
   }
 
-  const sourceLabels = useImplicitStdin ? ['<stdin>'] : positional.map((item) => (item === '-' ? '<stdin>' : item));
+  let sourceLabels = useImplicitStdin ? ['<stdin>'] : positional.map((item) => (item === '-' ? '<stdin>' : item));
   if (sourceLabels.filter((item) => item === '<stdin>').length > 1) {
     console.error('Error: stdin can only be used once.');
     process.exit(1);
   }
 
   if (streamMessagesMode) {
-    await runStreamMessagesMode(sourceLabels, { rdfMode });
+    await runStreamMessagesMode(sourceLabels, { rdfMode, storeName, storePath, storeClear });
     return;
   }
 
+  if (storeName && rdfMode) {
+    const lineBasedSources = sourceLabels.filter(sourceLooksLikeLineBasedRdf);
+    if (lineBasedSources.length) {
+      if (showAst) {
+        console.error('Error: line-based --store ingestion cannot be combined with --ast.');
+        process.exit(1);
+      }
+      if (streamMode) {
+        console.error('Error: line-based --store ingestion cannot be combined with --stream.');
+        process.exit(1);
+      }
+      if (engine.getProofCommentsEnabled()) {
+        console.error('Error: line-based --store ingestion currently does not support proof output.');
+        process.exit(1);
+      }
+
+      const store = await createCliStore({ storeName, storePath, storeClear });
+      try {
+        for (const sourceLabel of lineBasedSources) {
+          try {
+            await ingestLineBasedRdfSourceToStore(sourceLabel, store, { rdfMode });
+          } catch (e) {
+            console.error(`Error streaming RDF source ${JSON.stringify(sourceLabel)}: ${e && e.message ? e.message : String(e)}`);
+            process.exit(1);
+          }
+        }
+
+        sourceLabels = sourceLabels.filter((sourceLabel) => !sourceLooksLikeLineBasedRdf(sourceLabel));
+        if (!sourceLabels.length) return;
+
+        const parsedRuleSources = [];
+        for (const sourceLabel of sourceLabels) {
+          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 {
+            parsedRuleSources.push(
+              parseN3Text(text, {
+                baseIri: __sourceLabelToBaseIri(sourceLabel),
+                label: sourceLabel,
+                collectUsedPrefixes: false,
+                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 mergedRuleDocument = mergeParsedDocuments(parsedRuleSources);
+        const result = await engine.runStoreBacked(mergedRuleDocument, store, { rdf: rdfMode });
+        const outTriples = result.queryMode ? result.queryTriples || [] : (result.derived || []).map((df) => df.fact);
+        if (result.queryMode) {
+          const bodyText = engine.prettyPrintQueryTriples(outTriples, result.prefixes);
+          if (bodyText) process.stdout.write(String(bodyText).replace(/\s*$/g, '') + '\n');
+        } else {
+          for (const tr of outTriples) console.log(engine.tripleToRdfCompatible(tr, result.prefixes));
+        }
+        return;
+      } finally {
+        if (store && typeof store.close === 'function') await store.close();
+      }
+    }
+  }
+
   const parsedSources = [];
   for (const sourceLabel of sourceLabels) {
     let text;
@@ -931,6 +1144,69 @@ function factsContainOutputStrings(triplesForOutput) {
   const hasQueries = Array.isArray(qrules) && qrules.length;
   const mayAutoRenderOutputStrings = programMayProduceOutputStrings(triples, frules, qrules);
 
+  if (storeName) {
+    if (streamMode) {
+      console.error('Error: --store cannot be combined with --stream yet.');
+      process.exit(1);
+    }
+
+    const storeResult = await engine.runAsync(
+      { prefixes, triples, frules, brules, logQueryRules: qrules },
+      {
+        proof: engine.getProofCommentsEnabled(),
+        rdf: rdfMode,
+        store: { name: storeName, clear: storeClear, path: storePath || undefined },
+      },
+    );
+
+    const storeFacts = storeResult.facts || [];
+    const storeDerived = storeResult.derived || [];
+    const storeHasQueries = !!storeResult.queryMode;
+    const storeOutTriples = storeHasQueries ? (storeResult.queryTriples || []) : (mayAutoRenderOutputStrings && !engine.getProofCommentsEnabled() ? [] : storeDerived.map((df) => df.fact));
+    const storeOutDerived = storeHasQueries ? (storeResult.queryDerived || []) : storeDerived;
+    const renderedOutputTriples = storeHasQueries ? storeOutTriples : storeFacts;
+
+    if (factsContainOutputStrings(renderedOutputTriples)) {
+      process.stdout.write(engine.collectOutputStringsFromFacts(renderedOutputTriples, prefixes));
+      if (storeResult.store && typeof storeResult.store.close === 'function') await storeResult.store.close();
+      return;
+    }
+
+    if (engine.getProofCommentsEnabled()) {
+      process.stdout.write(engine.renderProofDocument(storeOutDerived, storeDerived.concat(storeOutDerived || []), triples, prefixes, brules));
+      if (storeResult.store && typeof storeResult.store.close === 'function') await storeResult.store.close();
+      return;
+    }
+
+    let bodyText = '';
+    if (rdfMode) bodyText = storeOutTriples.map((tr) => engine.tripleToRdfCompatible(tr, prefixes)).join('\n');
+    else if (storeHasQueries) bodyText = engine.prettyPrintQueryTriples(storeOutTriples, prefixes);
+
+    let usedPrefixes = prefixes.prefixesUsedForOutput(storeOutTriples);
+    if (rdfMode && bodyText) usedPrefixes = usedPrefixes.filter(([pfx]) => pfx === '' || bodyText.includes(pfx + ':'));
+
+    if (rdfMode && bodyText.includes('<<(')) {
+      console.log('VERSION "1.2"');
+      console.log();
+    }
+
+    for (const [pfx, base] of usedPrefixes) {
+      if (pfx === '') console.log(`@prefix : <${base}> .`);
+      else console.log(`@prefix ${pfx}: <${base}> .`);
+    }
+    if (storeOutTriples.length && usedPrefixes.length) console.log();
+
+    if (bodyText) process.stdout.write(String(bodyText).replace(/\s*$/g, '') + '\n');
+    else {
+      for (const df of storeOutDerived) {
+        console.log(rdfMode ? engine.tripleToRdfCompatible(df.fact, prefixes) : engine.tripleToN3(df.fact, prefixes));
+      }
+    }
+
+    if (storeResult.store && typeof storeResult.store.close === 'function') await storeResult.store.close();
+    return;
+  }
+
   if (streamMode && !hasQueries && !mayAutoRenderOutputStrings && !engine.getProofCommentsEnabled()) {
     const usedInInput = mergedDocument.usedPrefixes instanceof Set ? new Set(mergedDocument.usedPrefixes) : new Set();
     const outPrefixes = restrictPrefixEnv(prefixes, usedInInput);