eyeling 1.28.9 → 1.29.0

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

@@ -710,6 +710,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 +749,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 +785,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')) {
@@ -776,6 +811,10 @@ async function main() {
 
 
   if (streamMessagesMode) {
+    if (storeName) {
+      console.error('Error: --store cannot be combined with --stream-messages yet.');
+      process.exit(1);
+    }
     if (!rdfMode) {
       console.error('Error: --stream-messages requires -r/--rdf.');
       process.exit(1);
@@ -931,6 +970,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);

package/lib/engine.js

@@ -97,6 +97,7 @@ const {
   getDataFactory,
   internalTripleToRdfJsQuads,
   normalizeParsedReasonerInputSync,
+  normalizeParsedReasonerInputAsync,
   normalizeReasonerInputSync,
   normalizeReasonerInputAsync,
 } = require('./rdfjs');
@@ -105,6 +106,7 @@ const trace = require('./trace');
 const { deterministicSkolemIdFromKey } = require('./skolem');
 
 const deref = require('./deref');
+const { createFactStore, collectStore, MemoryFactStore, PersistentFactStore } = require('./store');
 
 const hasOwn = Object.prototype.hasOwnProperty;
 
@@ -3783,6 +3785,120 @@ function reasonStream(input, opts = {}) {
   return __out;
 }
 
+
+async function __parseRunAsyncInput(input, opts) {
+  const {
+    baseIri = null,
+    proof = false,
+    rdf = false,
+    sourceLabel = '<input>',
+  } = opts || {};
+
+  const parsedSourceList = parseN3SourceList(input, { baseIri, rdf: !!rdf, sourceLocations: !!proof });
+  if (parsedSourceList) return parsedSourceList;
+
+  const parsedObject = await normalizeParsedReasonerInputAsync(input);
+  if (parsedObject) {
+    if (baseIri && parsedObject.prefixes && typeof parsedObject.prefixes.setBase === 'function') parsedObject.prefixes.setBase(baseIri);
+    return parsedObject;
+  }
+
+  const n3Text = await normalizeReasonerInputAsync(input);
+  return parseN3Text(n3Text, {
+    baseIri: baseIri || '',
+    label: sourceLabel || '<input>',
+    keepSourceArtifacts: false,
+    sourceLocations: !!proof,
+    rdf: !!rdf,
+  });
+}
+
+function __withoutStoreOptions(opts) {
+  const out = { ...(opts || {}) };
+  delete out.store;
+  delete out.storePath;
+  delete out.storeClear;
+  return out;
+}
+
+function __normalizeStoreOption(opts) {
+  const cfg = opts && opts.store;
+  if (!cfg) return null;
+  if (typeof cfg === 'string') return { name: cfg, path: opts.storePath || undefined, clear: !!opts.storeClear };
+  if (typeof cfg === 'object') {
+    return {
+      ...cfg,
+      path: cfg.path || opts.storePath || undefined,
+      clear: !!(cfg.clear || opts.storeClear),
+    };
+  }
+  throw new TypeError('runAsync option "store" must be a store name string or a store options object');
+}
+
+async function runAsync(input, opts = {}) {
+  const storeConfig = __normalizeStoreOption(opts);
+  const runOpts = __withoutStoreOptions(opts);
+
+  // No store configured: keep ordinary in-memory behavior, but accept async RDF/JS
+  // iterables by normalizing the input before calling the synchronous engine.
+  if (!storeConfig) {
+    const normalizedInput = parseN3SourceList(input, {
+      baseIri: runOpts.baseIri || null,
+      rdf: !!runOpts.rdf,
+      sourceLocations: !!runOpts.proof,
+    }) || (await normalizeReasonerInputAsync(input));
+    return reasonStream(normalizedInput, runOpts);
+  }
+
+  const store = await createFactStore(storeConfig);
+  let closeStore = true;
+  try {
+    const parsed = await __parseRunAsyncInput(input, runOpts);
+
+    // Persist the newly supplied explicit facts first, then include all stored
+    // facts as the starting closure for this run.  This lets --store reuse facts
+    // across runs while keeping the current in-memory prover semantics intact.
+    await store.batchAdd(parsed.triples || [], 'explicit');
+    const storedTriples = await collectStore(store);
+
+    const storedKeys = new Set();
+    for (const tr of storedTriples) storedKeys.add(require('./store').tripleToStoreKey(tr));
+    const mergedTriples = storedTriples.slice();
+    for (const tr of parsed.triples || []) {
+      const key = require('./store').tripleToStoreKey(tr);
+      if (!storedKeys.has(key)) {
+        storedKeys.add(key);
+        mergedTriples.push(tr);
+      }
+    }
+
+    const result = reasonStream(
+      {
+        prefixes: parsed.prefixes,
+        triples: mergedTriples,
+        frules: parsed.frules,
+        brules: parsed.brules,
+        logQueryRules: parsed.logQueryRules,
+      },
+      runOpts,
+    );
+
+    await store.batchAdd((result.derived || []).map((df) => df.fact), 'inferred');
+    result.store = store;
+    closeStore = false;
+    return result;
+  } catch (e) {
+    await store.close();
+    throw e;
+  } finally {
+    // Keep result.store usable for callers.  On exceptional paths it is closed
+    // above; on success callers may close it when they are done.
+    if (closeStore) {
+      try { await store.close(); } catch {}
+    }
+  }
+}
+
 function reasonRdfJs(input, opts = {}) {
   const { dataFactory = null, skipUnsupportedRdfJs = false, ...restOpts } = opts || {};
   const rdfFactory = getDataFactory(dataFactory);
@@ -3890,6 +4006,7 @@ function setTracePrefixes(v) {
 
 module.exports = {
   reasonStream,
+  runAsync,
   reasonRdfJs,
   collectLogQueryConclusions,
   forwardChainAndCollectLogQueryConclusions,
@@ -3926,4 +4043,7 @@ module.exports = {
   loadBuiltinModule,
   listBuiltinIris,
   INFERENCE_FUSE_EXIT_CODE,
+  createFactStore,
+  MemoryFactStore,
+  PersistentFactStore,
 };

package/lib/entry.js

@@ -17,6 +17,7 @@ const { dataFactory } = require('./rdfjs');
 module.exports = {
   // public
   reasonStream: engine.reasonStream,
+  runAsync: engine.runAsync,
   reasonRdfJs: engine.reasonRdfJs,
   rdfjs: dataFactory,
   main: engine.main,
@@ -41,6 +42,9 @@ module.exports = {
   registerBuiltinModule: engine.registerBuiltinModule,
   loadBuiltinModule: engine.loadBuiltinModule,
   listBuiltinIris: engine.listBuiltinIris,
+  createFactStore: engine.createFactStore,
+  MemoryFactStore: engine.MemoryFactStore,
+  PersistentFactStore: engine.PersistentFactStore,
   getEnforceHttpsEnabled: engine.getEnforceHttpsEnabled,
   setEnforceHttpsEnabled: engine.setEnforceHttpsEnabled,
   getProofCommentsEnabled: engine.getProofCommentsEnabled,

package/lib/rdfjs.js

@@ -952,6 +952,7 @@ module.exports = {
   internalTripleToRdfJsQuads,
   internalTripleToRdfJsQuadInGraph,
   normalizeParsedReasonerInputSync,
+  normalizeParsedReasonerInputAsync,
   normalizeReasonerInputSync,
   normalizeReasonerInputAsync,
   hasEyelingObjectInput,