eyeling 1.22.15 → 1.23.0

package/examples/output/tunnel-junction-wake-switch-becoming.txt

@@ -0,0 +1,21 @@
+tunnel-junction wake switch — becoming
+
+Answer
+YES for the tunnel junction.
+NO for the conventional low-bias PN junction in the same wake-switch regime.
+
+Reason Why
+The tunnel junction can be read as a becoming under low forward bias. Because it is modeled as a heavily doped narrow PN junction with overlapping states, it can become a quantum-transfer state. In that regime it can become a sub-threshold current state, and under peak-to-valley scanning it can also become a negative differential response state. As a wake-switch device, that lets it become an ultra-low-bias switching state and finally a leak-alarm wake-serving state. By contrast, the conventional junction lacks the structural conditions needed for the same transition into quantum transfer, so the later wake-serving becoming is blocked as well.
+
+Check
+B1  OK - the tunnel junction can become a quantum-transfer state
+B2  OK - the tunnel junction is classified as tunneling-dominant
+B3  OK - the tunnel junction can become a sub-threshold current state
+B4  OK - the tunnel junction can become a negative differential response state
+B5  OK - the tunnel junction can become an ultra-low-bias switching state
+B6  OK - the tunnel junction can become a leak-alarm wake-serving state
+B7  OK - the conventional junction cannot become a quantum-transfer state
+B8  OK - the conventional junction cannot become a sub-threshold current state
+B9  OK - the conventional junction cannot become the tunnel-style negative differential state
+B10 OK - the conventional junction cannot become an ultra-low-bias switching state here
+B11 OK - the conventional junction cannot become a leak-alarm wake-serving state in this case

package/examples/tunnel-junction-wake-switch-becoming.n3

@@ -0,0 +1,216 @@
+# =================================================================================
+# tunnel-junction wake switch — becoming
+#
+# This example reframes the wake-switch case as a becoming example.
+# The device is not treated as a static component with capabilities, but as a
+# system that can or cannot pass into a low-bias wake-triggering state.
+#
+# We compare two devices:
+#   - tunnelJunction   : a heavily doped narrow PN junction with overlapping states
+#   - ordinaryJunction : a conventional PN junction without that overlap
+#
+# The point is to show:
+#   - what the tunnel junction can become under the low-bias requirement
+#   - what the conventional junction cannot become under the same requirement
+# =================================================================================
+
+@prefix : <http://example.org/tunnel-junction-wake-switch-becoming/> .
+@prefix arc: <https://example.org/arc#> .
+@prefix log: <http://www.w3.org/2000/10/swap/log#> .
+
+:case a arc:Case ;
+  arc:question "Can a tunnel-junction wake switch become a low-bias wake-triggering state in a regime where a conventional PN junction cannot?" .
+
+# -------------------
+# Application context
+# -------------------
+
+:leakAlarmNode a :EdgeSensor ;
+  :needs :MicrowattWakeSwitching ;
+  :application :PipeLeakAlarm .
+
+# ----------------------------------
+# Device A: tunnel-style PN junction
+# ----------------------------------
+
+:tunnelJunction a :PNJunction ;
+  :junctionKind :TunnelDiode ;
+  :doping :Heavy ;
+  :depletionWidth :Narrow ;
+  :stateAlignment :Overlap ;
+  :biasRegime :LowForwardBias ;
+  :scanProfile :PeakToValley ;
+  :deviceRole :WakeSwitch .
+
+# ----------------------------------
+# Device B: conventional PN junction
+# ----------------------------------
+
+:ordinaryJunction a :PNJunction ;
+  :junctionKind :ConventionalDiode ;
+  :doping :Standard ;
+  :depletionWidth :Wide ;
+  :stateAlignment :NoOverlap ;
+  :biasRegime :LowForwardBias ;
+  :scanProfile :MonotoneForward ;
+  :deviceRole :WakeSwitch .
+
+# -------------------------------------------
+# CAN-BECOME rules — viable state transitions
+# -------------------------------------------
+
+# A heavily doped, narrow junction with overlapping states can become a
+# quantum-transfer-supporting junction.
+{ ?J a :PNJunction ;
+     :doping :Heavy ;
+     :depletionWidth :Narrow ;
+     :stateAlignment :Overlap . }
+=>
+{ ?J :canBecome :QuantumTransferState ;
+     :transportMode :TunnelingDominant . } .
+
+# In the low-forward-bias regime, a junction in the quantum-transfer state can
+# become a sub-threshold current state.
+{ ?J :canBecome :QuantumTransferState ;
+     :biasRegime :LowForwardBias . }
+=>
+{ ?J :canBecome :SubThresholdCurrentState . } .
+
+# If the junction is scanned across the peak-to-valley window, it can become a
+# negative differential response state.
+{ ?J :canBecome :QuantumTransferState ;
+     :scanProfile :PeakToValley . }
+=>
+{ ?J :canBecome :NegativeDifferentialResponseState . } .
+
+# A wake-switch device that can become a sub-threshold current state can become
+# an ultra-low-bias switching state.
+{ ?J :canBecome :SubThresholdCurrentState ;
+     :deviceRole :WakeSwitch . }
+=>
+{ ?J :canBecome :UltraLowBiasSwitchingState . } .
+
+# If the device can become an ultra-low-bias switching state and the node needs
+# microwatt wake switching, it can become a wake-serving device.
+{ ?J :canBecome :UltraLowBiasSwitchingState .
+  :leakAlarmNode :needs :MicrowattWakeSwitching . }
+=>
+{ ?J :canBecome :LeakAlarmWakeServingState . } .
+
+# -----------------------------------------------
+# CANNOT-BECOME rules — blocked state transitions
+# -----------------------------------------------
+
+# A conventional wide-depletion low-bias junction without state overlap cannot
+# become a quantum-transfer-supporting junction.
+{ ?J a :PNJunction ;
+     :doping :Standard ;
+     :depletionWidth :Wide ;
+     :stateAlignment :NoOverlap . }
+=>
+{ ?J :cannotBecome :QuantumTransferState . } .
+
+# Without that quantum-transfer state, the junction cannot become a
+# sub-threshold current state in the same low-bias regime.
+{ ?J :cannotBecome :QuantumTransferState ;
+     :biasRegime :LowForwardBias . }
+=>
+{ ?J :cannotBecome :SubThresholdCurrentState . } .
+
+# Without quantum transfer, the tunnel-style negative differential state is
+# blocked as well.
+{ ?J :cannotBecome :QuantumTransferState . }
+=>
+{ ?J :cannotBecome :NegativeDifferentialResponseState . } .
+
+# Without sub-threshold current, the device cannot become an ultra-low-bias
+# switching state.
+{ ?J :cannotBecome :SubThresholdCurrentState ;
+     :deviceRole :WakeSwitch . }
+=>
+{ ?J :cannotBecome :UltraLowBiasSwitchingState . } .
+
+# Without ultra-low-bias switching, the device cannot become a wake-serving
+# device for the leak-alarm node.
+{ ?J :cannotBecome :UltraLowBiasSwitchingState .
+  :leakAlarmNode :needs :MicrowattWakeSwitching . }
+=>
+{ ?J :cannotBecome :LeakAlarmWakeServingState . } .
+
+# ------
+# Checks
+# ------
+
+{ :tunnelJunction :canBecome :QuantumTransferState . }
+=> { :case :checkB1 :Passed . } .
+
+{ :tunnelJunction :transportMode :TunnelingDominant . }
+=> { :case :checkB2 :Passed . } .
+
+{ :tunnelJunction :canBecome :SubThresholdCurrentState . }
+=> { :case :checkB3 :Passed . } .
+
+{ :tunnelJunction :canBecome :NegativeDifferentialResponseState . }
+=> { :case :checkB4 :Passed . } .
+
+{ :tunnelJunction :canBecome :UltraLowBiasSwitchingState . }
+=> { :case :checkB5 :Passed . } .
+
+{ :tunnelJunction :canBecome :LeakAlarmWakeServingState . }
+=> { :case :checkB6 :Passed . } .
+
+{ :ordinaryJunction :cannotBecome :QuantumTransferState . }
+=> { :case :checkB7 :Passed . } .
+
+{ :ordinaryJunction :cannotBecome :SubThresholdCurrentState . }
+=> { :case :checkB8 :Passed . } .
+
+{ :ordinaryJunction :cannotBecome :NegativeDifferentialResponseState . }
+=> { :case :checkB9 :Passed . } .
+
+{ :ordinaryJunction :cannotBecome :UltraLowBiasSwitchingState . }
+=> { :case :checkB10 :Passed . } .
+
+{ :ordinaryJunction :cannotBecome :LeakAlarmWakeServingState . }
+=> { :case :checkB11 :Passed . } .
+
+# ----------------
+# ARC-style output
+# ----------------
+
+{ :case :checkB1 :Passed .
+  :case :checkB2 :Passed .
+  :case :checkB3 :Passed .
+  :case :checkB4 :Passed .
+  :case :checkB5 :Passed .
+  :case :checkB6 :Passed .
+  :case :checkB7 :Passed .
+  :case :checkB8 :Passed .
+  :case :checkB9 :Passed .
+  :case :checkB10 :Passed .
+  :case :checkB11 :Passed . }
+=>
+{
+  :out log:outputString """tunnel-junction wake switch — becoming
+
+Answer
+YES for the tunnel junction.
+NO for the conventional low-bias PN junction in the same wake-switch regime.
+
+Reason Why
+The tunnel junction can be read as a becoming under low forward bias. Because it is modeled as a heavily doped narrow PN junction with overlapping states, it can become a quantum-transfer state. In that regime it can become a sub-threshold current state, and under peak-to-valley scanning it can also become a negative differential response state. As a wake-switch device, that lets it become an ultra-low-bias switching state and finally a leak-alarm wake-serving state. By contrast, the conventional junction lacks the structural conditions needed for the same transition into quantum transfer, so the later wake-serving becoming is blocked as well.
+
+Check
+B1  OK - the tunnel junction can become a quantum-transfer state
+B2  OK - the tunnel junction is classified as tunneling-dominant
+B3  OK - the tunnel junction can become a sub-threshold current state
+B4  OK - the tunnel junction can become a negative differential response state
+B5  OK - the tunnel junction can become an ultra-low-bias switching state
+B6  OK - the tunnel junction can become a leak-alarm wake-serving state
+B7  OK - the conventional junction cannot become a quantum-transfer state
+B8  OK - the conventional junction cannot become a sub-threshold current state
+B9  OK - the conventional junction cannot become the tunnel-style negative differential state
+B10 OK - the conventional junction cannot become an ultra-low-bias switching state here
+B11 OK - the conventional junction cannot become a leak-alarm wake-serving state in this case
+""" .
+} .

package/eyeling.js

@@ -4921,6 +4921,7 @@ const { pathToFileURL } = require('node:url');
 const engine = require('./engine');
 const deref = require('./deref');
 const { PrefixEnv } = require('./prelude');
+const { parseN3Text, mergeParsedDocuments } = require('./multisource');
 
 function offsetToLineCol(text, offset) {
   const chars = Array.from(text);
@@ -5004,8 +5005,9 @@ function main() {
 
   function printHelp(toStderr = false) {
     const msg =
-      `Usage: ${prog} [options] [file.n3|-]\n\n` +
-      `When no file is given and stdin is piped, read N3 from stdin.\n\n` +
+      `Usage: ${prog} [options] [file-or-url.n3|- ...]\n\n` +
+      `When no file is given and stdin is piped, read N3 from stdin.\n` +
+      `When multiple inputs are given, parse each source separately, merge ASTs, then reason once.\n\n` +
       `Options:\n` +
       `  -a, --ast                    Print parsed AST as JSON and exit.\n` +
       `      --builtin <module.js>    Load a custom builtin module (repeatable).\n` +
@@ -5049,7 +5051,7 @@ function main() {
       builtinModules.push(a.slice('--builtin='.length));
       continue;
     }
-    if (!a.startsWith('-')) positional.push(a);
+    if (a === '-' || !a.startsWith('-')) positional.push(a);
   }
 
   const showAst = argv.includes('--ast') || argv.includes('-a');
@@ -5075,17 +5077,12 @@ function main() {
     if (typeof engine.setSuperRestrictedMode === 'function') engine.setSuperRestrictedMode(true);
   }
 
-  // Positional args (the N3 file)
+  // Positional args (one or more N3 sources).
   const useImplicitStdin = positional.length === 0 && !process.stdin.isTTY;
   if (positional.length === 0 && !useImplicitStdin) {
     printHelp(false);
     process.exit(0);
   }
-  if (positional.length > 1) {
-    console.error('Error: expected at most one input [file.n3|-].');
-    printHelp(true);
-    process.exit(1);
-  }
 
   for (const spec of builtinModules) {
     try {
@@ -5097,35 +5094,47 @@ function main() {
     }
   }
 
-  const sourceLabel = useImplicitStdin || positional[0] === '-' ? '<stdin>' : positional[0];
-  const baseIri = __sourceLabelToBaseIri(sourceLabel);
-
-  let text;
-  try {
-    text = __readInputSourceSync(sourceLabel);
-  } catch (e) {
-    if (sourceLabel === '<stdin>') console.error(`Error reading stdin: ${e.message}`);
-    else console.error(`Error reading file ${JSON.stringify(sourceLabel)}: ${e.message}`);
+  const 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);
   }
 
-  let toks;
-  let prefixes, triples, frules, brules, qrules;
-  try {
-    toks = engine.lex(text);
-    const parser = new engine.Parser(toks);
-    if (baseIri) parser.prefixes.setBase(baseIri);
-    [prefixes, triples, frules, brules, qrules] = parser.parseDocument();
-    // Make the parsed prefixes available to log:trace output (CLI path)
-    engine.setTracePrefixes(prefixes);
-  } catch (e) {
-    if (e && e.name === 'N3SyntaxError') {
-      console.error(formatN3SyntaxError(e, text, sourceLabel));
+  const parsedSources = [];
+  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);
     }
-    throw e;
+
+    try {
+      parsedSources.push(
+        parseN3Text(text, {
+          baseIri: __sourceLabelToBaseIri(sourceLabel),
+          label: sourceLabel,
+        }),
+      );
+    } catch (e) {
+      if (e && e.name === 'N3SyntaxError') {
+        console.error(formatN3SyntaxError(e, text, sourceLabel));
+        process.exit(1);
+      }
+      throw e;
+    }
   }
 
+  const mergedDocument = mergeParsedDocuments(parsedSources);
+  const prefixes = mergedDocument.prefixes;
+  const triples = mergedDocument.triples;
+  const frules = mergedDocument.frules;
+  const brules = mergedDocument.brules;
+  const qrules = mergedDocument.logQueryRules;
+  const tokenSets = parsedSources.map((source) => ({ tokens: source.tokens, prefixes: source.prefixes }));
+
   if (showAst) {
     function astReplacer(unusedJsonKey, value) {
       if (value instanceof Set) return Array.from(value);
@@ -5267,7 +5276,10 @@ function main() {
   const mayAutoRenderOutputStrings = programMayProduceOutputStrings(triples, frules, qrules);
 
   if (streamMode && !hasQueries && !mayAutoRenderOutputStrings) {
-    const usedInInput = prefixesUsedInInputTokens(toks, prefixes);
+    const usedInInput = new Set();
+    for (const source of tokenSets) {
+      for (const pfx of prefixesUsedInInputTokens(source.tokens, source.prefixes)) usedInInput.add(pfx);
+    }
     const outPrefixes = restrictPrefixEnv(prefixes, usedInInput);
 
     // Ensure log:trace uses the same compact prefix set as the output.
@@ -5861,6 +5873,7 @@ const EMPTY_LIST_TERM = new ListTerm([]);
 const { lex, N3SyntaxError } = require('./lexer');
 const { Parser } = require('./parser');
 const { liftBlankRuleVars } = require('./rules');
+const { parseN3SourceList } = require('./multisource');
 
 const {
   makeBuiltins,
@@ -9202,7 +9215,8 @@ function reasonStream(input, opts = {}) {
     builtinModules = null,
   } = opts;
 
-  const parsedInput = normalizeParsedReasonerInputSync(input);
+  const parsedSourceList = parseN3SourceList(input, { baseIri });
+  const parsedInput = parsedSourceList || normalizeParsedReasonerInputSync(input);
   const rdfFactory = rdfjs ? getDataFactory(dataFactory) : null;
 
   const __oldEnforceHttps = deref.getEnforceHttpsEnabled();
@@ -9345,7 +9359,7 @@ function reasonRdfJs(input, opts = {}) {
 
   Promise.resolve().then(async () => {
     try {
-      const normalizedInput = await normalizeReasonerInputAsync(input);
+      const normalizedInput = parseN3SourceList(input, restOpts) || (await normalizeReasonerInputAsync(input));
       reasonStream(normalizedInput, {
         ...restOpts,
         rdfjs: false,
@@ -10532,6 +10546,213 @@ function lex(inputText) {
 
 module.exports = { Token, N3SyntaxError, lex, decodeN3StringEscapes };
 
+  };
+  __modules["lib/multisource.js"] = function(require, module, exports){
+/**
+ * Eyeling Reasoner — multi-source parsing helpers
+ *
+ * These helpers let the CLI/API parse several N3 documents independently and
+ * merge their parsed ASTs before reasoning. This avoids building one giant N3
+ * string while preserving the existing lexer/parser/engine pipeline.
+ */
+
+'use strict';
+
+const { lex } = require('./lexer');
+const { Parser } = require('./parser');
+const {
+  Blank,
+  ListTerm,
+  OpenListTerm,
+  GraphTerm,
+  Triple,
+  Rule,
+  PrefixEnv,
+  annotateQuotedGraphTerm,
+} = require('./prelude');
+
+function emptyParsedDocument() {
+  return {
+    prefixes: PrefixEnv.newDefault(),
+    triples: [],
+    frules: [],
+    brules: [],
+    logQueryRules: [],
+  };
+}
+
+function parseN3Text(text, opts = {}) {
+  const { baseIri = '', label = '<input>' } = opts || {};
+  const tokens = lex(text);
+  const parser = new Parser(tokens);
+  if (baseIri) parser.prefixes.setBase(baseIri);
+  const [prefixes, triples, frules, brules, logQueryRules] = parser.parseDocument();
+  return { prefixes, triples, frules, brules, logQueryRules, tokens, text, label };
+}
+
+function sourceBlankPrefix(sourceIndex) {
+  return `_:src${sourceIndex}_`;
+}
+
+function scopedBlankLabel(label, sourceIndex, mapping) {
+  const key = String(label || '');
+  let out = mapping.get(key);
+  if (out) return out;
+
+  const bare = key.startsWith('_:') ? key.slice(2) : key;
+  out = sourceBlankPrefix(sourceIndex) + bare;
+  mapping.set(key, out);
+  return out;
+}
+
+function scopeBlankNodesInDocument(doc, sourceIndex) {
+  const mapping = new Map();
+
+  function cloneTerm(term) {
+    if (term instanceof Blank) return new Blank(scopedBlankLabel(term.label, sourceIndex, mapping));
+    if (term instanceof ListTerm) return new ListTerm(term.elems.map(cloneTerm));
+    if (term instanceof OpenListTerm) return new OpenListTerm(term.prefix.map(cloneTerm), term.tailVar);
+    if (term instanceof GraphTerm) return annotateQuotedGraphTerm(new GraphTerm(term.triples.map(cloneTriple)));
+    return term;
+  }
+
+  function cloneTriple(triple) {
+    return new Triple(cloneTerm(triple.s), cloneTerm(triple.p), cloneTerm(triple.o));
+  }
+
+  function cloneRule(rule) {
+    const headBlankLabels = new Set();
+    if (rule && rule.headBlankLabels instanceof Set) {
+      for (const label of rule.headBlankLabels) headBlankLabels.add(scopedBlankLabel(label, sourceIndex, mapping));
+    }
+
+    const out = new Rule(
+      (rule.premise || []).map(cloneTriple),
+      (rule.conclusion || []).map(cloneTriple),
+      rule.isForward,
+      rule.isFuse,
+      headBlankLabels,
+    );
+
+    if (rule && Object.prototype.hasOwnProperty.call(rule, '__dynamicConclusionTerm')) {
+      Object.defineProperty(out, '__dynamicConclusionTerm', {
+        value: cloneTerm(rule.__dynamicConclusionTerm),
+        enumerable: false,
+        writable: false,
+        configurable: true,
+      });
+    }
+
+    return out;
+  }
+
+  return {
+    prefixes: doc.prefixes,
+    triples: (doc.triples || []).map(cloneTriple),
+    frules: (doc.frules || []).map(cloneRule),
+    brules: (doc.brules || []).map(cloneRule),
+    logQueryRules: (doc.logQueryRules || []).map(cloneRule),
+    tokens: doc.tokens,
+    text: doc.text,
+    label: doc.label,
+  };
+}
+
+function mergePrefixEnvs(target, source) {
+  if (!source) return target;
+  const map = source.map || {};
+  for (const [prefix, iri] of Object.entries(map)) {
+    // Every parser starts with an empty default namespace. Do not let a later
+    // source that never declared ':' erase a useful default namespace from an
+    // earlier source; prefix merging is for output readability only.
+    if (iri || !Object.prototype.hasOwnProperty.call(target.map, prefix)) target.set(prefix, iri);
+  }
+  if (source.baseIri) target.setBase(source.baseIri);
+  return target;
+}
+
+function mergeParsedDocuments(docs, opts = {}) {
+  const documents = Array.isArray(docs) ? docs : [];
+  const scopeBlankNodes =
+    typeof opts.scopeBlankNodes === 'boolean' ? opts.scopeBlankNodes : documents.length > 1;
+
+  const merged = emptyParsedDocument();
+  const mergedSources = [];
+
+  for (let i = 0; i < documents.length; i++) {
+    const originalDoc = documents[i] || emptyParsedDocument();
+    const doc = scopeBlankNodes ? scopeBlankNodesInDocument(originalDoc, i + 1) : originalDoc;
+
+    mergePrefixEnvs(merged.prefixes, doc.prefixes);
+    merged.triples.push(...(doc.triples || []));
+    merged.frules.push(...(doc.frules || []));
+    merged.brules.push(...(doc.brules || []));
+    merged.logQueryRules.push(...(doc.logQueryRules || []));
+    mergedSources.push(doc);
+  }
+
+  Object.defineProperty(merged, 'sources', {
+    value: mergedSources,
+    enumerable: false,
+    writable: false,
+    configurable: true,
+  });
+
+  return merged;
+}
+
+function isN3SourceListInput(input) {
+  return !!(
+    input &&
+    typeof input === 'object' &&
+    !Array.isArray(input) &&
+    Array.isArray(input.sources)
+  );
+}
+
+function normalizeN3SourceItem(source, index) {
+  const sourceNumber = index + 1;
+  if (typeof source === 'string') {
+    return { text: source, label: `<source ${sourceNumber}>`, baseIri: '' };
+  }
+  if (!source || typeof source !== 'object' || Array.isArray(source)) {
+    throw new TypeError('Each N3 source must be a string or an object with an n3/text field');
+  }
+
+  const text = typeof source.n3 === 'string' ? source.n3 : typeof source.text === 'string' ? source.text : null;
+  if (text === null) throw new TypeError('Each N3 source object must provide an n3 or text string');
+
+  return {
+    text,
+    label: typeof source.label === 'string' && source.label ? source.label : `<source ${sourceNumber}>`,
+    baseIri: typeof source.baseIri === 'string' ? source.baseIri : '',
+  };
+}
+
+function parseN3SourceList(input, opts = {}) {
+  if (!isN3SourceListInput(input)) return null;
+  const sources = input.sources.map(normalizeN3SourceItem);
+  const defaultBaseIri = typeof opts.baseIri === 'string' ? opts.baseIri : '';
+  const parsed = sources.map((source, index) =>
+    parseN3Text(source.text, {
+      label: source.label,
+      baseIri: source.baseIri || (sources.length === 1 ? defaultBaseIri : ''),
+    }),
+  );
+  return mergeParsedDocuments(parsed, {
+    scopeBlankNodes: typeof input.scopeBlankNodes === 'boolean' ? input.scopeBlankNodes : parsed.length > 1,
+  });
+}
+
+module.exports = {
+  emptyParsedDocument,
+  parseN3Text,
+  mergeParsedDocuments,
+  scopeBlankNodesInDocument,
+  isN3SourceListInput,
+  parseN3SourceList,
+};
+
   };
   __modules["lib/parser.js"] = function(require, module, exports){
 /**

package/index.d.ts

@@ -120,6 +120,13 @@ declare module 'eyeling' {
 
   export type EyelingAstBundle = [EyelingPrefixEnv, EyelingTriple[], EyelingRule[], EyelingRule[], EyelingRule[]?];
 
+  export type N3Source = string | { n3?: string; text?: string; baseIri?: string; label?: string };
+
+  export interface N3SourceListInput {
+    sources: N3Source[];
+    scopeBlankNodes?: boolean;
+  }
+
   export interface RdfJsReasonInput {
     n3?: string;
     quads?: Iterable<RdfJsQuad> | AsyncIterable<RdfJsQuad>;
@@ -189,13 +196,16 @@ declare module 'eyeling' {
     queryQuads?: RdfJsQuad[];
   }
 
-  export function reason(opts: ReasonOptions, input: string | RdfJsReasonInput | EyelingAstBundle): string;
+  export function reason(
+    opts: ReasonOptions,
+    input: string | RdfJsReasonInput | EyelingAstBundle | N3SourceListInput,
+  ): string;
   export function reasonStream(
-    input: string | RdfJsReasonInput | EyelingAstBundle,
+    input: string | RdfJsReasonInput | EyelingAstBundle | N3SourceListInput,
     opts?: ReasonStreamOptions,
   ): ReasonStreamResult;
   export function reasonRdfJs(
-    input: string | RdfJsReasonInput | EyelingAstBundle,
+    input: string | RdfJsReasonInput | EyelingAstBundle | N3SourceListInput,
     opts?: Omit<ReasonStreamOptions, 'rdfjs' | 'onDerived'>,
   ): AsyncIterable<RdfJsQuad>;
 
@@ -212,16 +222,18 @@ declare module 'eyeling/browser' {
   export type RdfJsQuad = import('eyeling').RdfJsQuad;
   export type RdfJsReasonInput = import('eyeling').RdfJsReasonInput;
   export type EyelingAstBundle = import('eyeling').EyelingAstBundle;
+  export type N3Source = import('eyeling').N3Source;
+  export type N3SourceListInput = import('eyeling').N3SourceListInput;
   export type ReasonStreamOptions = import('eyeling').ReasonStreamOptions;
   export type ReasonStreamResult = import('eyeling').ReasonStreamResult;
   export type BuiltinHandler = import('eyeling').BuiltinHandler;
 
   export function reasonStream(
-    input: string | RdfJsReasonInput | EyelingAstBundle,
+    input: string | RdfJsReasonInput | EyelingAstBundle | N3SourceListInput,
     opts?: ReasonStreamOptions,
   ): ReasonStreamResult;
   export function reasonRdfJs(
-    input: string | RdfJsReasonInput | EyelingAstBundle,
+    input: string | RdfJsReasonInput | EyelingAstBundle | N3SourceListInput,
     opts?: Omit<ReasonStreamOptions, 'rdfjs' | 'onDerived'>,
   ): AsyncIterable<RdfJsQuad>;