eyeling 1.28.9 → 1.29.1

package/eyeling.js

@@ -5842,10 +5842,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, {
@@ -5859,7 +5861,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;
@@ -5871,9 +5873,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 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 }) {
+
+async function runStreamMessagesMode(sourceLabels, { rdfMode, storeName = null, storePath = null, storeClear = false } = {}) {
   const ordinarySourceLabels = [];
   const messageSourceLabels = [];
 
@@ -5922,40 +6014,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();
   }
 }
 
@@ -5990,6 +6091,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`;
@@ -6026,6 +6130,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);
   }
 
@@ -6033,6 +6166,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')) {
@@ -6091,17 +6227,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;
@@ -6211,6 +6424,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);
@@ -6886,6 +7162,7 @@ const {
   getDataFactory,
   internalTripleToRdfJsQuads,
   normalizeParsedReasonerInputSync,
+  normalizeParsedReasonerInputAsync,
   normalizeReasonerInputSync,
   normalizeReasonerInputAsync,
 } = require('./rdfjs');
@@ -6894,6 +7171,7 @@ const trace = require('./trace');
 const { deterministicSkolemIdFromKey } = require('./skolem');
 
 const deref = require('./deref');
+const { createFactStore, collectStore, MemoryFactStore, PersistentFactStore, tripleToStoreKey } = require('./store');
 
 const hasOwn = Object.prototype.hasOwnProperty;
 
@@ -10572,6 +10850,278 @@ 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 __storePatternTerm(t, subst) {
+  const applied = applySubstTerm(t, subst || __emptySubst());
+  return containsVarTerm(applied) ? null : applied;
+}
+
+function __mergeStoreSubst(base, delta) {
+  let out = base;
+  for (const k of Object.keys(delta || {})) {
+    const v = delta[k];
+    if (Object.prototype.hasOwnProperty.call(out, k)) {
+      if (!termsEqual(out[k], v)) return null;
+    } else {
+      if (out === base) out = __cloneSubst(base);
+      out[k] = v;
+    }
+  }
+  return out;
+}
+
+async function __proveGoalsAgainstStore(goals, subst, store, backRules, localFacts, depth, varGen, opts = {}) {
+  if (!Array.isArray(goals) || goals.length === 0) return [subst || __emptySubst()];
+  if (depth > 64) return [];
+
+  const goal0 = applySubstTriple(goals[0], subst || __emptySubst());
+  const rest = goals.slice(1);
+  const out = [];
+
+  if (isBuiltinPred(goal0.p)) {
+    const deltas = evalBuiltin(goal0, __emptySubst(), localFacts || [], backRules || [], depth, varGen, undefined);
+    for (const delta of deltas) {
+      const nextSubst = __mergeStoreSubst(subst || __emptySubst(), delta);
+      if (nextSubst === null) continue;
+      out.push(...await __proveGoalsAgainstStore(rest, nextSubst, store, backRules, localFacts, depth + 1, varGen, opts));
+      if (opts.maxResults && out.length >= opts.maxResults) return out.slice(0, opts.maxResults);
+    }
+    return out;
+  }
+
+  // Backward rules are kept in memory; they may call back into the persistent
+  // fact store for their own premises.
+  if (goal0.p instanceof Iri && Array.isArray(backRules) && backRules.length) {
+    ensureBackRuleIndexes(backRules);
+    const candRules = (backRules.__byHeadPred.get(goal0.p.__tid) || []).concat(backRules.__wildHeadPred || []);
+    for (const r of candRules) {
+      if (!r || !Array.isArray(r.conclusion) || r.conclusion.length !== 1) continue;
+      const rStd = standardizeRule(r, varGen);
+      const head = rStd.conclusion[0];
+      const s2 = unifyTriple(head, goal0, subst || __emptySubst());
+      if (s2 === null) continue;
+      const newGoals = (rStd.premise || []).concat(rest);
+      out.push(...await __proveGoalsAgainstStore(newGoals, s2, store, backRules, localFacts, depth + 1, varGen, opts));
+      if (opts.maxResults && out.length >= opts.maxResults) return out.slice(0, opts.maxResults);
+    }
+  }
+
+  const sPat = __storePatternTerm(goal0.s, subst || __emptySubst());
+  const pPat = __storePatternTerm(goal0.p, subst || __emptySubst());
+  const oPat = __storePatternTerm(goal0.o, subst || __emptySubst());
+
+  for await (const fact of store.match(sPat, pPat, oPat)) {
+    const s2 = unifyTriple(goal0, fact, subst || __emptySubst());
+    if (s2 === null) continue;
+    out.push(...await __proveGoalsAgainstStore(rest, s2, store, backRules, localFacts, depth + 1, varGen, opts));
+    if (opts.maxResults && out.length >= opts.maxResults) return out.slice(0, opts.maxResults);
+  }
+
+  return out;
+}
+
+async function runStoreBacked(input, store, opts = {}) {
+  const parsed = parseN3SourceList(input, {
+    baseIri: opts.baseIri || null,
+    rdf: !!opts.rdf,
+    sourceLocations: !!opts.proof,
+  }) || input;
+
+  const prefixes = parsed.prefixes;
+  const triples = parsed.triples || [];
+  const frules = parsed.frules || [];
+  const brules = parsed.brules || [];
+  const qrules = parsed.logQueryRules || [];
+
+  materializeRdfLists(triples, frules.concat(qrules || []), brules);
+  await store.batchAdd(triples, 'explicit');
+
+  const derived = [];
+  const derivedKeys = new Set();
+  const varGen = [0];
+  const maxIterations = Number.isInteger(opts.maxIterations) && opts.maxIterations > 0 ? opts.maxIterations : 1024;
+
+  for (let iteration = 0; iteration < maxIterations; iteration += 1) {
+    let changed = false;
+    for (let ruleIndex = 0; ruleIndex < frules.length; ruleIndex += 1) {
+      const r = frules[ruleIndex];
+      if (!r || r.isFuse || r.__dynamicConclusionTerm) continue;
+      __prepareForwardRule(r);
+      const solutions = await __proveGoalsAgainstStore(r.premise || [], __emptySubst(), store, brules, triples, 0, varGen, {});
+      for (const subst of solutions) {
+        for (const cpat of r.conclusion || []) {
+          const fact = applySubstTriple(cpat, subst);
+          if (!isGroundTriple(fact)) continue;
+          if (await store.add(fact, 'inferred')) {
+            const df = makeDerivedRecord(fact, r, (r.premise || []).map((p) => applySubstTriple(p, subst)), subst, false);
+            const key = tripleToStoreKey(fact);
+            if (!derivedKeys.has(key)) {
+              derivedKeys.add(key);
+              derived.push(df);
+            }
+            changed = true;
+          }
+        }
+      }
+    }
+    if (!changed) break;
+  }
+
+  let queryTriples = [];
+  const queryDerived = [];
+  if (qrules.length) {
+    for (const r of qrules) {
+      const solutions = await __proveGoalsAgainstStore(r.premise || [], __emptySubst(), store, brules, triples, 0, varGen, {});
+      for (const subst of solutions) {
+        for (const cpat of r.conclusion || []) {
+          const fact = applySubstTriple(cpat, subst);
+          if (!isGroundTriple(fact)) continue;
+          queryTriples.push(fact);
+          queryDerived.push(makeDerivedRecord(fact, r, (r.premise || []).map((p) => applySubstTriple(p, subst)), subst, false));
+        }
+      }
+    }
+  }
+
+  if (queryTriples.length) {
+    const seen = new Set();
+    queryTriples = queryTriples.filter((tr) => {
+      const key = tripleToStoreKey(tr);
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+  }
+
+  return {
+    prefixes,
+    facts: [],
+    derived,
+    queryMode: !!qrules.length,
+    queryTriples,
+    queryDerived,
+    closureN3: qrules.length
+      ? prettyPrintQueryTriples(queryTriples, prefixes)
+      : derived.map((df) => (opts.rdf ? tripleToRdfCompatible(df.fact, prefixes) : tripleToN3(df.fact, prefixes))).join('\n'),
+    store,
+    storeBacked: true,
+  };
+}
+
+
+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);
@@ -10679,6 +11229,8 @@ function setTracePrefixes(v) {
 
 module.exports = {
   reasonStream,
+  runAsync,
+  runStoreBacked,
   reasonRdfJs,
   collectLogQueryConclusions,
   forwardChainAndCollectLogQueryConclusions,
@@ -10715,6 +11267,9 @@ module.exports = {
   loadBuiltinModule,
   listBuiltinIris,
   INFERENCE_FUSE_EXIT_CODE,
+  createFactStore,
+  MemoryFactStore,
+  PersistentFactStore,
 };
 
   };
@@ -10738,6 +11293,7 @@ const { dataFactory } = require('./rdfjs');
 module.exports = {
   // public
   reasonStream: engine.reasonStream,
+  runAsync: engine.runAsync,
   reasonRdfJs: engine.reasonRdfJs,
   rdfjs: dataFactory,
   main: engine.main,
@@ -10762,6 +11318,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,
@@ -17050,6 +17609,7 @@ module.exports = {
   internalTripleToRdfJsQuads,
   internalTripleToRdfJsQuadInGraph,
   normalizeParsedReasonerInputSync,
+  normalizeParsedReasonerInputAsync,
   normalizeReasonerInputSync,
   normalizeReasonerInputAsync,
   hasEyelingObjectInput,
@@ -17215,6 +17775,697 @@ module.exports = {
   deterministicSkolemIdFromKey,
 };
 
+  };
+  __modules["lib/store.js"] = function(require, module, exports){
+/**
+ * Eyeling Reasoner — fact stores
+ *
+ * Optional async fact-store abstraction used by runAsync() and by tests.  The
+ * in-memory reasoner remains the default; persistent stores are opt-in.
+ */
+
+'use strict';
+
+const {
+  Iri,
+  Literal,
+  Var,
+  Blank,
+  ListTerm,
+  OpenListTerm,
+  GraphTerm,
+  Triple,
+} = require('./prelude');
+
+const KIND_EXPLICIT = 1;
+const KIND_INFERRED = 2;
+
+function __dynamicRequire(name) {
+  try {
+    // Keep this indirect so the browser bundle can include this module without
+    // eagerly trying to bundle Node-only or optional Level dependencies.
+    const req = typeof require === 'function' ? require : null;
+    return req ? req(name) : null;
+  } catch {
+    return null;
+  }
+}
+
+function base64url(s) {
+  const text = String(s);
+  if (typeof Buffer !== 'undefined') return Buffer.from(text, 'utf8').toString('base64url');
+  const encoder = globalThis.TextEncoder ? new globalThis.TextEncoder() : null;
+  if (!encoder || typeof globalThis.btoa !== 'function') {
+    throw new Error('No UTF-8/base64 encoder available for persistent store keys');
+  }
+  const bytes = encoder.encode(text);
+  let bin = '';
+  for (const b of bytes) bin += String.fromCharCode(b);
+  return globalThis.btoa(bin).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '');
+}
+
+function idPart(id) {
+  return String(id).padStart(16, '0');
+}
+
+function safeStoreName(name) {
+  const text = String(name || 'default');
+  return encodeURIComponent(text).replace(/%/g, '_');
+}
+
+function termToJson(term) {
+  if (term instanceof Iri) return ['Iri', term.value];
+  if (term instanceof Literal) return ['Literal', term.value];
+  if (term instanceof Var) return ['Var', term.name];
+  if (term instanceof Blank) return ['Blank', term.label];
+  if (term instanceof ListTerm) return ['ListTerm', term.elems.map(termToJson)];
+  if (term instanceof OpenListTerm) return ['OpenListTerm', term.prefix.map(termToJson), term.tailVar];
+  if (term instanceof GraphTerm) return ['GraphTerm', term.triples.map(tripleToJson)];
+
+  // RDF/JS terms, for callers that use the store abstraction directly.
+  if (term && typeof term === 'object' && typeof term.termType === 'string') {
+    switch (term.termType) {
+      case 'NamedNode':
+        return ['Iri', term.value];
+      case 'BlankNode':
+        return ['Blank', term.value && term.value.startsWith('_:') ? term.value : `_:${term.value}`];
+      case 'Variable':
+        return ['Var', term.value];
+      case 'Literal': {
+        const dt = term.datatype && term.datatype.termType === 'NamedNode' ? term.datatype.value : '';
+        const lang = typeof term.language === 'string' ? term.language : '';
+        const q = JSON.stringify(String(term.value));
+        if (lang) return ['Literal', `${q}@${lang}`];
+        if (!dt || dt === 'http://www.w3.org/2001/XMLSchema#string') return ['Literal', q];
+        return ['Literal', `${q}^^<${dt}>`];
+      }
+      case 'Quad':
+        return ['GraphTerm', [tripleToJson({ s: term.subject, p: term.predicate, o: term.object })]];
+      case 'DefaultGraph':
+        return ['DefaultGraph'];
+      default:
+        break;
+    }
+  }
+
+  throw new TypeError(`Unsupported fact-store term: ${term && term.constructor ? term.constructor.name : String(term)}`);
+}
+
+function termFromJson(json) {
+  if (!Array.isArray(json)) throw new TypeError('Invalid serialized term');
+  switch (json[0]) {
+    case 'Iri':
+      return new Iri(json[1]);
+    case 'Literal':
+      return new Literal(json[1]);
+    case 'Var':
+      return new Var(json[1]);
+    case 'Blank':
+      return new Blank(json[1]);
+    case 'ListTerm':
+      return new ListTerm((json[1] || []).map(termFromJson));
+    case 'OpenListTerm':
+      return new OpenListTerm((json[1] || []).map(termFromJson), json[2]);
+    case 'GraphTerm':
+      return new GraphTerm((json[1] || []).map(tripleFromJson));
+    case 'DefaultGraph':
+      return new Iri('urn:eyeling:default-graph');
+    default:
+      throw new TypeError(`Unsupported serialized term type: ${json[0]}`);
+  }
+}
+
+function tripleToJson(triple) {
+  return [termToJson(triple.s || triple.subject), termToJson(triple.p || triple.predicate), termToJson(triple.o || triple.object)];
+}
+
+function tripleFromJson(json) {
+  return new Triple(termFromJson(json[0]), termFromJson(json[1]), termFromJson(json[2]));
+}
+
+function termToStoreKey(term) {
+  return JSON.stringify(termToJson(term));
+}
+
+function tripleToStoreKey(triple) {
+  return JSON.stringify(tripleToJson(triple));
+}
+
+function kindMask(kind) {
+  if (kind === 'explicit') return KIND_EXPLICIT;
+  if (kind === 'inferred') return KIND_INFERRED;
+  if (typeof kind === 'number') return kind & (KIND_EXPLICIT | KIND_INFERRED);
+  return KIND_EXPLICIT;
+}
+
+class MemoryKv {
+  constructor() {
+    this.map = new Map();
+  }
+
+  async get(key) {
+    return this.map.get(key);
+  }
+
+  async put(key, value) {
+    this.map.set(key, value);
+  }
+
+  async del(key) {
+    this.map.delete(key);
+  }
+
+  async clear() {
+    this.map.clear();
+  }
+
+  async batch(ops) {
+    for (const op of ops || []) {
+      if (!op) continue;
+      if (op.type === 'del') this.map.delete(op.key);
+      else this.map.set(op.key, op.value);
+    }
+  }
+
+  async *entries(prefix = '') {
+    const keys = Array.from(this.map.keys())
+      .filter((key) => key.startsWith(prefix))
+      .sort();
+    for (const key of keys) yield [key, this.map.get(key)];
+  }
+
+  async close() {}
+}
+
+class JsonFileKv extends MemoryKv {
+  constructor(filePath) {
+    super();
+    this.filePath = filePath;
+    this.loaded = false;
+    this.dirty = false;
+  }
+
+  async open() {
+    if (this.loaded) return;
+    this.loaded = true;
+    const fs = __dynamicRequire('node:fs');
+    const path = __dynamicRequire('node:path');
+    if (!fs || !path) throw new Error('Persistent stores need node:fs in this runtime');
+    fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+    if (!fs.existsSync(this.filePath)) return;
+    const text = fs.readFileSync(this.filePath, 'utf8');
+    if (!text.trim()) return;
+    const data = JSON.parse(text);
+    this.map = new Map(Array.isArray(data.entries) ? data.entries : []);
+  }
+
+  async flush() {
+    if (!this.loaded || !this.dirty) return;
+    const fs = __dynamicRequire('node:fs');
+    const path = __dynamicRequire('node:path');
+    fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+    const tmp = `${this.filePath}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify({ entries: Array.from(this.map.entries()) }), 'utf8');
+    fs.renameSync(tmp, this.filePath);
+    this.dirty = false;
+  }
+
+  async get(key) {
+    await this.open();
+    return super.get(key);
+  }
+
+  async put(key, value) {
+    await this.open();
+    await super.put(key, value);
+    this.dirty = true;
+    await this.flush();
+  }
+
+  async del(key) {
+    await this.open();
+    await super.del(key);
+    this.dirty = true;
+    await this.flush();
+  }
+
+  async clear() {
+    await this.open();
+    await super.clear();
+    this.dirty = true;
+    await this.flush();
+  }
+
+  async batch(ops) {
+    await this.open();
+    await super.batch(ops);
+    this.dirty = true;
+    await this.flush();
+  }
+
+  async *entries(prefix = '') {
+    await this.open();
+    yield* super.entries(prefix);
+  }
+
+  async close() {
+    await this.flush();
+  }
+}
+
+class ClassicLevelKv {
+  constructor(location) {
+    const classic = __dynamicRequire('classic-level');
+    const ClassicLevel = classic && (classic.ClassicLevel || classic.Level || classic.default);
+    if (!ClassicLevel) throw new Error('classic-level is not installed');
+    const fs = __dynamicRequire('node:fs');
+    const path = __dynamicRequire('node:path');
+    if (fs && path) fs.mkdirSync(path.dirname(location), { recursive: true });
+    this.db = new ClassicLevel(location, { valueEncoding: 'json', createIfMissing: true, errorIfExists: false });
+    this.opened = false;
+  }
+
+  async open() {
+    if (this.opened) return;
+    if (typeof this.db.open === 'function') await this.db.open();
+    this.opened = true;
+  }
+
+  async get(key) {
+    await this.open();
+    try {
+      return await this.db.get(key);
+    } catch (e) {
+      if (e && (e.notFound || e.code === 'LEVEL_NOT_FOUND' || e.code === 'NOT_FOUND')) return undefined;
+      throw e;
+    }
+  }
+
+  async put(key, value) {
+    await this.open();
+    await this.db.put(key, value);
+  }
+
+  async del(key) {
+    await this.open();
+    await this.db.del(key);
+  }
+
+  async clear() {
+    await this.open();
+    if (typeof this.db.clear === 'function') await this.db.clear();
+    else {
+      const ops = [];
+      for await (const [key] of this.entries('')) ops.push({ type: 'del', key });
+      if (ops.length) await this.batch(ops);
+    }
+  }
+
+  async batch(ops) {
+    await this.open();
+    if (!ops || !ops.length) return;
+    await this.db.batch(ops);
+  }
+
+  async *entries(prefix = '') {
+    await this.open();
+    const gte = prefix;
+    const lt = prefix + '\uffff';
+    const iterator = this.db.iterator({ gte, lt });
+    for await (const item of iterator) {
+      if (Array.isArray(item)) yield item;
+      else if (item && Array.isArray(item.key)) yield item.key;
+    }
+  }
+
+  async close() {
+    if (this.db && typeof this.db.close === 'function') await this.db.close();
+  }
+}
+
+class IndexedDbKv {
+  constructor(name) {
+    this.name = name;
+    this.dbPromise = null;
+  }
+
+  open() {
+    if (this.dbPromise) return this.dbPromise;
+    const idb = typeof globalThis !== 'undefined' ? globalThis.indexedDB : null;
+    if (!idb) throw new Error('IndexedDB is not available in this runtime');
+    this.dbPromise = new Promise((resolve, reject) => {
+      const req = idb.open(`eyeling:${this.name}`, 1);
+      req.onupgradeneeded = () => {
+        const db = req.result;
+        if (!db.objectStoreNames.contains('kv')) db.createObjectStore('kv');
+      };
+      req.onerror = () => reject(req.error || new Error('Failed to open IndexedDB store'));
+      req.onsuccess = () => resolve(req.result);
+    });
+    return this.dbPromise;
+  }
+
+  async __tx(mode, fn) {
+    const db = await this.open();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction('kv', mode);
+      const store = tx.objectStore('kv');
+      let value;
+      tx.oncomplete = () => resolve(value);
+      tx.onerror = () => reject(tx.error || new Error('IndexedDB transaction failed'));
+      tx.onabort = () => reject(tx.error || new Error('IndexedDB transaction aborted'));
+      try {
+        value = fn(store, resolve, reject);
+      } catch (e) {
+        try { tx.abort(); } catch {}
+        reject(e);
+      }
+    });
+  }
+
+  async get(key) {
+    return this.__tx('readonly', (store, resolve, reject) => {
+      const req = store.get(key);
+      req.onerror = () => reject(req.error);
+      req.onsuccess = () => resolve(req.result);
+    });
+  }
+
+  async put(key, value) {
+    return this.__tx('readwrite', (store) => {
+      store.put(value, key);
+    });
+  }
+
+  async del(key) {
+    return this.__tx('readwrite', (store) => {
+      store.delete(key);
+    });
+  }
+
+  async clear() {
+    return this.__tx('readwrite', (store) => {
+      store.clear();
+    });
+  }
+
+  async batch(ops) {
+    return this.__tx('readwrite', (store) => {
+      for (const op of ops || []) {
+        if (op.type === 'del') store.delete(op.key);
+        else store.put(op.value, op.key);
+      }
+    });
+  }
+
+  async *entries(prefix = '') {
+    const db = await this.open();
+    const rows = await new Promise((resolve, reject) => {
+      const tx = db.transaction('kv', 'readonly');
+      const store = tx.objectStore('kv');
+      const out = [];
+      const range = globalThis.IDBKeyRange.bound(prefix, prefix + '\uffff', false, true);
+      const req = store.openCursor(range);
+      req.onerror = () => reject(req.error);
+      req.onsuccess = () => {
+        const cursor = req.result;
+        if (!cursor) return;
+        out.push([cursor.key, cursor.value]);
+        cursor.continue();
+      };
+      tx.oncomplete = () => resolve(out);
+      tx.onerror = () => reject(tx.error || new Error('IndexedDB transaction failed'));
+    });
+    for (const row of rows) yield row;
+  }
+
+  async close() {
+    if (!this.dbPromise) return;
+    const db = await this.dbPromise;
+    if (db && typeof db.close === 'function') db.close();
+  }
+}
+
+class MemoryFactStore {
+  constructor() {
+    this.map = new Map();
+  }
+
+  async add(triple, kind = 'explicit') {
+    const key = tripleToStoreKey(triple);
+    const prev = this.map.get(key);
+    const mask = kindMask(kind);
+    if (prev) {
+      const nextKind = prev.kind | mask;
+      if (nextKind !== prev.kind) prev.kind = nextKind;
+      return false;
+    }
+    this.map.set(key, { triple, kind: mask });
+    return true;
+  }
+
+  async batchAdd(triples, kind = 'explicit') {
+    let n = 0;
+    for (const triple of triples || []) if (await this.add(triple, kind)) n += 1;
+    return n;
+  }
+
+  async has(triple) {
+    return this.map.has(tripleToStoreKey(triple));
+  }
+
+  async kindOf(triple) {
+    const row = this.map.get(tripleToStoreKey(triple));
+    return row ? row.kind : 0;
+  }
+
+  async *match(s, p, o) {
+    const sk = s == null ? null : termToStoreKey(s);
+    const pk = p == null ? null : termToStoreKey(p);
+    const ok = o == null ? null : termToStoreKey(o);
+    for (const { triple } of this.map.values()) {
+      if (sk !== null && termToStoreKey(triple.s) !== sk) continue;
+      if (pk !== null && termToStoreKey(triple.p) !== pk) continue;
+      if (ok !== null && termToStoreKey(triple.o) !== ok) continue;
+      yield triple;
+    }
+  }
+
+  async clear() {
+    this.map.clear();
+  }
+
+  async close() {}
+}
+
+class PersistentFactStore {
+  constructor(kv, options = {}) {
+    this.kv = kv;
+    this.termCacheByKey = new Map();
+    this.termCacheById = new Map();
+    this.name = options.name || 'default';
+  }
+
+  async clear() {
+    await this.kv.clear();
+    this.termCacheByKey.clear();
+    this.termCacheById.clear();
+  }
+
+  async __nextTermId() {
+    const key = 'meta/nextTermId';
+    const current = Number((await this.kv.get(key)) || 1);
+    await this.kv.put(key, current + 1);
+    return idPart(current);
+  }
+
+  async __idForTerm(term, create) {
+    const canonical = termToStoreKey(term);
+    if (this.termCacheByKey.has(canonical)) return this.termCacheByKey.get(canonical);
+    const byLexKey = `term/byLex/${base64url(canonical)}`;
+    const found = await this.kv.get(byLexKey);
+    if (found !== undefined) {
+      this.termCacheByKey.set(canonical, found);
+      return found;
+    }
+    if (!create) return null;
+    const id = await this.__nextTermId();
+    const json = termToJson(term);
+    await this.kv.batch([
+      { type: 'put', key: byLexKey, value: id },
+      { type: 'put', key: `term/byId/${id}`, value: json },
+    ]);
+    this.termCacheByKey.set(canonical, id);
+    this.termCacheById.set(id, term);
+    return id;
+  }
+
+  async __termById(id) {
+    if (this.termCacheById.has(id)) return this.termCacheById.get(id);
+    const json = await this.kv.get(`term/byId/${id}`);
+    if (json === undefined) throw new Error(`Corrupt fact store: missing term ${id}`);
+    const term = termFromJson(json);
+    this.termCacheById.set(id, term);
+    return term;
+  }
+
+  async __tripleFromIds(sid, pid, oid) {
+    return new Triple(await this.__termById(sid), await this.__termById(pid), await this.__termById(oid));
+  }
+
+  async add(triple, kind = 'explicit') {
+    const sid = await this.__idForTerm(triple.s, true);
+    const pid = await this.__idForTerm(triple.p, true);
+    const oid = await this.__idForTerm(triple.o, true);
+    const mask = kindMask(kind);
+    const primary = `triple/${sid}/${pid}/${oid}`;
+    const prev = await this.kv.get(primary);
+    if (prev !== undefined) {
+      const nextKind = (typeof prev === 'number' ? prev : prev.kind || 0) | mask;
+      if (nextKind !== prev) await this.kv.put(primary, nextKind);
+      return false;
+    }
+    await this.kv.batch([
+      { type: 'put', key: primary, value: mask },
+      { type: 'put', key: `i/spo/${sid}/${pid}/${oid}`, value: mask },
+      { type: 'put', key: `i/pos/${pid}/${oid}/${sid}`, value: mask },
+      { type: 'put', key: `i/osp/${oid}/${sid}/${pid}`, value: mask },
+    ]);
+    return true;
+  }
+
+  async batchAdd(triples, kind = 'explicit') {
+    let n = 0;
+    for (const triple of triples || []) if (await this.add(triple, kind)) n += 1;
+    return n;
+  }
+
+  async has(triple) {
+    return (await this.kindOf(triple)) !== 0;
+  }
+
+  async kindOf(triple) {
+    const sid = await this.__idForTerm(triple.s, false);
+    if (sid === null) return 0;
+    const pid = await this.__idForTerm(triple.p, false);
+    if (pid === null) return 0;
+    const oid = await this.__idForTerm(triple.o, false);
+    if (oid === null) return 0;
+    const value = await this.kv.get(`triple/${sid}/${pid}/${oid}`);
+    return typeof value === 'number' ? value : value && typeof value.kind === 'number' ? value.kind : 0;
+  }
+
+  async __idsForPattern(s, p, o) {
+    const sid = s == null ? null : await this.__idForTerm(s, false);
+    const pid = p == null ? null : await this.__idForTerm(p, false);
+    const oid = o == null ? null : await this.__idForTerm(o, false);
+    if ((s != null && sid === null) || (p != null && pid === null) || (o != null && oid === null)) return null;
+    return { sid, pid, oid };
+  }
+
+  __scanPlan(sid, pid, oid) {
+    if (sid && pid && oid) return { index: 'triple', prefix: `triple/${sid}/${pid}/${oid}`, order: 'spo' };
+    if (sid && pid) return { index: 'spo', prefix: `i/spo/${sid}/${pid}/`, order: 'spo' };
+    if (pid && oid) return { index: 'pos', prefix: `i/pos/${pid}/${oid}/`, order: 'pos' };
+    if (sid && oid) return { index: 'osp', prefix: `i/osp/${oid}/${sid}/`, order: 'osp' };
+    if (pid) return { index: 'pos', prefix: `i/pos/${pid}/`, order: 'pos' };
+    if (sid) return { index: 'spo', prefix: `i/spo/${sid}/`, order: 'spo' };
+    if (oid) return { index: 'osp', prefix: `i/osp/${oid}/`, order: 'osp' };
+    return { index: 'spo', prefix: 'i/spo/', order: 'spo' };
+  }
+
+  __decodeIndexKey(key, plan) {
+    if (plan.index === 'triple') {
+      const parts = key.split('/');
+      return { sid: parts[1], pid: parts[2], oid: parts[3] };
+    }
+    const rest = key.slice(`i/${plan.index}/`.length).split('/');
+    if (plan.order === 'spo') return { sid: rest[0], pid: rest[1], oid: rest[2] };
+    if (plan.order === 'pos') return { pid: rest[0], oid: rest[1], sid: rest[2] };
+    return { oid: rest[0], sid: rest[1], pid: rest[2] };
+  }
+
+  async *match(s, p, o) {
+    const ids = await this.__idsForPattern(s, p, o);
+    if (!ids) return;
+    const plan = this.__scanPlan(ids.sid, ids.pid, ids.oid);
+    const seen = new Set();
+    for await (const [key] of this.kv.entries(plan.prefix)) {
+      const row = this.__decodeIndexKey(key, plan);
+      if (ids.sid && row.sid !== ids.sid) continue;
+      if (ids.pid && row.pid !== ids.pid) continue;
+      if (ids.oid && row.oid !== ids.oid) continue;
+      const primary = `${row.sid}/${row.pid}/${row.oid}`;
+      if (seen.has(primary)) continue;
+      seen.add(primary);
+      yield this.__tripleFromIds(row.sid, row.pid, row.oid);
+    }
+  }
+
+  async close() {
+    if (this.kv && typeof this.kv.close === 'function') await this.kv.close();
+  }
+}
+
+function nodeStoreLocation(name, storePath) {
+  const path = __dynamicRequire('node:path');
+  const os = __dynamicRequire('node:os');
+  if (!path || !os) return null;
+  const base = storePath || path.join(os.homedir ? os.homedir() : '.', '.eyeling-store');
+  return path.join(base, safeStoreName(name));
+}
+
+async function createPersistentFactStore(options = {}) {
+  const name = typeof options === 'string' ? options : options.name || 'default';
+  const clear = !!(options && options.clear);
+  let kv;
+
+  if (typeof globalThis !== 'undefined' && globalThis.indexedDB && !__dynamicRequire('node:fs')) {
+    kv = new IndexedDbKv(name);
+  } else {
+    const location = nodeStoreLocation(name, options && options.path);
+    try {
+      kv = new ClassicLevelKv(location);
+    } catch {
+      kv = new JsonFileKv(`${location}.json`);
+    }
+  }
+
+  const store = new PersistentFactStore(kv, { name });
+  if (clear) await store.clear();
+  return store;
+}
+
+async function createFactStore(options = null) {
+  if (!options) return new MemoryFactStore();
+  if (typeof options === 'string') return createPersistentFactStore({ name: options });
+  if (options.type === 'memory') return new MemoryFactStore();
+  if (options.backend === 'memory') return new MemoryFactStore();
+  return createPersistentFactStore(options);
+}
+
+async function collectStore(store) {
+  const out = [];
+  for await (const tr of store.match(null, null, null)) out.push(tr);
+  return out;
+}
+
+module.exports = {
+  KIND_EXPLICIT,
+  KIND_INFERRED,
+  MemoryFactStore,
+  PersistentFactStore,
+  createFactStore,
+  createPersistentFactStore,
+  collectStore,
+  termToStoreKey,
+  tripleToStoreKey,
+  termToJson,
+  termFromJson,
+  tripleToJson,
+  tripleFromJson,
+};
+
   };
   __modules["lib/time.js"] = function(require, module, exports){
 /**