eyeling 1.27.9 → 1.28.1

package/lib/cli.js

@@ -8,10 +8,13 @@
 'use strict';
 
 const fs = require('node:fs');
-const os = require('node:os');
 const path = require('node:path');
-const { pathToFileURL, fileURLToPath } = require('node:url');
+const { pathToFileURL, fileURLToPath, URL } = require('node:url');
 const { TextDecoder } = require('node:util');
+const http = require('node:http');
+const https = require('node:https');
+const readline = require('node:readline');
+const zlib = require('node:zlib');
 
 const engine = require('./engine');
 const deref = require('./deref');
@@ -145,7 +148,8 @@ function __httpFetchScriptBody({ prefixOnly = false } = {}) {
             if (finished) return;
             chunks.push(chunk);
             bytes += chunk.length;
-            if (bytes >= limit) finish();
+            const text = Buffer.concat(chunks, bytes).toString('utf8');
+            if (bytes >= limit || /^\\s*(?:@version|VERSION)\\s+(["'])(?:1\\.1|1\\.2|1\\.2-basic)-messages\\1\\s*\\.?\\s*(?:#.*)?$/im.test(text)) finish();
           });
           body.on('end', finish);
           body.on('error', (e) => { console.error(e && e.message ? e.message : String(e)); process.exit(5); });
@@ -174,22 +178,95 @@ function __readHttpPrefixSync(sourceLabel, byteLimit = 64 * 1024) {
   return r.stdout;
 }
 
-function __downloadHttpSourceToTempFileSync(sourceLabel) {
-  const cp = require('node:child_process');
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'eyeling-rdf-message-log-'));
-  const file = path.join(dir, 'source.txt');
-  const r = cp.spawnSync(process.execPath, ['-e', __httpFetchScriptBody({ prefixOnly: false }), sourceLabel, file], {
-    encoding: 'utf8',
-    maxBuffer: 1024 * 1024,
-    stdio: ['ignore', 'ignore', 'pipe'],
+function __openHttpTextStream(sourceLabel, redirects = 0) {
+  const maxRedirects = 10;
+  return new Promise((resolve, reject) => {
+    if (redirects > maxRedirects) {
+      reject(new Error('Too many redirects'));
+      return;
+    }
+
+    let parsed;
+    try {
+      parsed = new URL(sourceLabel);
+    } catch (e) {
+      reject(e);
+      return;
+    }
+
+    const mod = parsed.protocol === 'https:' ? https : parsed.protocol === 'http:' ? http : null;
+    if (!mod) {
+      reject(new Error(`Unsupported protocol ${parsed.protocol}`));
+      return;
+    }
+
+    const req = mod.request(
+      {
+        protocol: parsed.protocol,
+        hostname: parsed.hostname,
+        port: parsed.port || undefined,
+        path: parsed.pathname + parsed.search,
+        headers: {
+          accept: 'text/n3, text/turtle, application/trig, application/n-triples, application/n-quads, text/plain;q=0.8, */*;q=0.01',
+          'accept-encoding': 'identity',
+          'user-agent': 'eyeling-rdf-message-stream',
+        },
+      },
+      (res) => {
+        const sc = res.statusCode || 0;
+        if (sc >= 300 && sc < 400 && res.headers && res.headers.location) {
+          const next = new URL(res.headers.location, sourceLabel).toString();
+          res.resume();
+          resolve(__openHttpTextStream(next, redirects + 1));
+          return;
+        }
+        if (sc < 200 || sc >= 300) {
+          res.resume();
+          reject(new Error(`HTTP status ${sc}`));
+          return;
+        }
+
+        const enc = String((res.headers && res.headers['content-encoding']) || '').toLowerCase();
+        let body = res;
+        if (enc.includes('gzip')) body = res.pipe(zlib.createGunzip());
+        else if (enc.includes('deflate')) body = res.pipe(zlib.createInflate());
+        else if (enc.includes('br')) body = res.pipe(zlib.createBrotliDecompress());
+        resolve(body);
+      },
+    );
+    req.on('error', reject);
+    req.end();
   });
-  if (r.status !== 0) {
-    try { fs.rmSync(dir, { recursive: true, force: true }); } catch {}
-    throw new Error(`Failed to dereference ${sourceLabel}${r.stderr ? ': ' + String(r.stderr).trim() : ''}`);
-  }
-  return { file, cleanup: () => { try { fs.rmSync(dir, { recursive: true, force: true }); } catch {} } };
 }
 
+async function forEachLineInHttpSource(sourceLabel, onLine) {
+  const body = await __openHttpTextStream(sourceLabel);
+  await new Promise((resolve, reject) => {
+    let settled = false;
+    function done(err) {
+      if (settled) return;
+      settled = true;
+      if (err) reject(err);
+      else resolve();
+    }
+
+    const rl = readline.createInterface({ input: body, crlfDelay: Infinity });
+    rl.on('line', (line) => {
+      try {
+        onLine(line + '\n');
+      } catch (e) {
+        try { rl.close(); } catch {}
+        if (body && typeof body.destroy === 'function') {
+          try { body.destroy(); } catch {}
+        }
+        done(e);
+      }
+    });
+    rl.on('close', () => done());
+    rl.on('error', done);
+    body.on('error', done);
+  });
+}
 
 const RDF_MESSAGE_VERSION_RE = /^\s*(?:@version|VERSION)\s+(["'])(?:1\.1|1\.2|1\.2-basic)-messages\1\s*\.?\s*(?:#.*)?$/im;
 const RDF_MESSAGE_VERSION_LINE_RE = /^\s*(?:@version|VERSION)\s+(["'])(?:1\.1|1\.2|1\.2-basic)-messages\1\s*\.?\s*(?:#.*)?$/i;
@@ -407,15 +484,50 @@ function __forEachRdfMessageChunkSync(sourceLabel, onMessage) {
     return;
   }
   if (__isHttpSource(sourceLabel)) {
-    const tmp = __downloadHttpSourceToTempFileSync(sourceLabel);
-    try {
-      forEachRdfMessageChunkInFileSync(tmp.file, onMessage);
-    } finally {
-      tmp.cleanup();
+    throw new Error('internal error: HTTP RDF Message Logs must be streamed asynchronously');
+  }
+  forEachRdfMessageChunkInText(__readInputSourceSync(sourceLabel), onMessage);
+}
+
+
+async function forEachRdfMessageChunkInHttpSource(sourceLabel, onMessage) {
+  const directives = [];
+  const seenDirectives = new Set();
+  let chunk = '';
+  let messageIndex = 1;
+  let sawVersion = false;
+  let sawDelimiter = false;
+
+  function emit() {
+    onMessage({ messageIndex, chunk, directives: directives.slice() });
+    messageIndex += 1;
+    chunk = '';
+  }
+
+  await forEachLineInHttpSource(sourceLabel, (line) => {
+    if (RDF_MESSAGE_VERSION_LINE_RE.test(line)) {
+      sawVersion = true;
+      return;
+    }
+    if (RDF_MESSAGE_DELIMITER_LINE_RE.test(line)) {
+      emit();
+      sawDelimiter = true;
+      return;
     }
+    addRdfDirective(directives, seenDirectives, line);
+    chunk += line;
+  });
+
+  if (!sawVersion) throw new Error('not an RDF Message Log: missing VERSION "*-messages" directive');
+  if (sawDelimiter || hasRdfPayload(chunk)) emit();
+}
+
+async function __forEachRdfMessageChunk(sourceLabel, onMessage) {
+  if (__isHttpSource(sourceLabel)) {
+    await forEachRdfMessageChunkInHttpSource(sourceLabel, onMessage);
     return;
   }
-  forEachRdfMessageChunkInText(__readInputSourceSync(sourceLabel), onMessage);
+  __forEachRdfMessageChunkSync(sourceLabel, onMessage);
 }
 
 function factsContainOutputStrings(triplesForOutput) {
@@ -481,7 +593,7 @@ function runParsedDocumentOnce(mergedDocument, { rdfMode = false, outputPrefixes
   }
 }
 
-function runStreamMessagesMode(sourceLabels, { rdfMode }) {
+async function runStreamMessagesMode(sourceLabels, { rdfMode }) {
   const ordinarySourceLabels = [];
   const messageSourceLabels = [];
 
@@ -533,7 +645,7 @@ function runStreamMessagesMode(sourceLabels, { rdfMode }) {
   const fullIriPrefixes = new PrefixEnv({});
   for (const messageSourceLabel of messageSourceLabels) {
     try {
-      __forEachRdfMessageChunkSync(messageSourceLabel, ({ messageIndex, chunk, directives }) => {
+      await __forEachRdfMessageChunk(messageSourceLabel, ({ messageIndex, chunk, directives }) => {
         const messageText = buildSingleMessageReplayDocument({
           sourceLabel: messageSourceLabel,
           messageIndex,
@@ -567,7 +679,7 @@ function runStreamMessagesMode(sourceLabels, { rdfMode }) {
   }
 }
 
-function main() {
+async function main() {
   // Drop "node" and script name; keep only user-provided args
   // Expand combined short options: -pt == -p -t
   const argvRaw = process.argv.slice(2);
@@ -706,7 +818,7 @@ function main() {
   }
 
   if (streamMessagesMode) {
-    runStreamMessagesMode(sourceLabels, { rdfMode });
+    await runStreamMessagesMode(sourceLabels, { rdfMode });
     return;
   }
 
@@ -790,7 +902,8 @@ function main() {
     return false;
   }
 
-  function factsContainOutputStrings(triplesForOutput) {
+  
+function factsContainOutputStrings(triplesForOutput) {
     return (
       Array.isArray(triplesForOutput) &&
       triplesForOutput.some(

package/lib/engine.js

@@ -95,7 +95,7 @@ const {
 } = require('./printing');
 const {
   getDataFactory,
-  internalTripleToRdfJsQuad,
+  internalTripleToRdfJsQuads,
   normalizeParsedReasonerInputSync,
   normalizeReasonerInputSync,
   normalizeReasonerInputAsync,
@@ -3593,15 +3593,22 @@ function isUnsupportedRdfJsConversionError(err) {
   );
 }
 
-function maybeTripleToRdfJsQuad(triple, rdfFactory, skipUnsupportedRdfJs) {
+function maybeTripleToRdfJsQuads(triple, rdfFactory, skipUnsupportedRdfJs) {
   try {
-    return internalTripleToRdfJsQuad(triple, rdfFactory);
+    return internalTripleToRdfJsQuads(triple, rdfFactory);
   } catch (err) {
-    if (skipUnsupportedRdfJs && isUnsupportedRdfJsConversionError(err)) return null;
+    if (skipUnsupportedRdfJs && isUnsupportedRdfJsConversionError(err)) return [];
     throw err;
   }
 }
 
+function addRdfJsPayloadQuads(payload, quads) {
+  if (!Array.isArray(quads) || quads.length === 0) return payload;
+  payload.quads = quads;
+  if (quads.length === 1) payload.quad = quads[0];
+  return payload;
+}
+
 function reasonStream(input, opts = {}) {
   const {
     baseIri = null,
@@ -3629,7 +3636,8 @@ function reasonStream(input, opts = {}) {
         rdf: useRdfCompatibility,
       })
     : null;
-  const parsedInput = parsedSourceList || parsedTextInput || normalizeParsedReasonerInputSync(input);
+  const hasInlineN3 = input && typeof input === 'object' && !Array.isArray(input) && typeof input.n3 === 'string';
+  const parsedInput = parsedSourceList || parsedTextInput || (hasInlineN3 ? null : normalizeParsedReasonerInputSync(input));
   const rdfFactory = rdfjs ? getDataFactory(dataFactory) : null;
 
   const __oldEnforceHttps = deref.getEnforceHttpsEnabled();
@@ -3700,8 +3708,7 @@ function reasonStream(input, opts = {}) {
       for (const qdf of queryDerived) {
         const payload = { triple: useRdfCompatibility ? tripleToRdfCompatible(qdf.fact, prefixes) : tripleToN3(qdf.fact, prefixes), df: qdf };
         if (rdfFactory) {
-          const quad = maybeTripleToRdfJsQuad(qdf.fact, rdfFactory, skipUnsupportedRdfJs);
-          if (quad) payload.quad = quad;
+          addRdfJsPayloadQuads(payload, maybeTripleToRdfJsQuads(qdf.fact, rdfFactory, skipUnsupportedRdfJs));
         }
         onDerived(payload);
       }
@@ -3719,8 +3726,7 @@ function reasonStream(input, opts = {}) {
             df,
           };
           if (rdfFactory) {
-            const quad = maybeTripleToRdfJsQuad(df.fact, rdfFactory, skipUnsupportedRdfJs);
-            if (quad) payload.quad = quad;
+            addRdfJsPayloadQuads(payload, maybeTripleToRdfJsQuads(df.fact, rdfFactory, skipUnsupportedRdfJs));
           }
           onDerived(payload);
         }
@@ -3761,12 +3767,10 @@ function reasonStream(input, opts = {}) {
   };
 
   if (rdfFactory) {
-    __out.closureQuads = closureTriples
-      .map((t) => maybeTripleToRdfJsQuad(t, rdfFactory, skipUnsupportedRdfJs))
-      .filter(Boolean);
-    __out.queryQuads = queryTriples
-      .map((t) => maybeTripleToRdfJsQuad(t, rdfFactory, skipUnsupportedRdfJs))
-      .filter(Boolean);
+    __out.closureQuads = closureTriples.flatMap((t) =>
+      maybeTripleToRdfJsQuads(t, rdfFactory, skipUnsupportedRdfJs),
+    );
+    __out.queryQuads = queryTriples.flatMap((t) => maybeTripleToRdfJsQuads(t, rdfFactory, skipUnsupportedRdfJs));
   }
   deref.setEnforceHttpsEnabled(__oldEnforceHttps);
   return __out;
@@ -3797,9 +3801,9 @@ function reasonRdfJs(input, opts = {}) {
         ...restOpts,
         rdfjs: false,
         onDerived: ({ df }) => {
-          const quad = maybeTripleToRdfJsQuad(df.fact, rdfFactory, skipUnsupportedRdfJs);
-          if (quad) {
-            queue.push(quad);
+          const quads = maybeTripleToRdfJsQuads(df.fact, rdfFactory, skipUnsupportedRdfJs);
+          if (quads.length) {
+            queue.push(...quads);
             flush();
           }
         },
@@ -3828,7 +3832,15 @@ function reasonRdfJs(input, opts = {}) {
 // Minimal export surface for Node + browser/worker
 function main() {
   // Lazily require to avoid hard cycles in the module graph.
-  return require('./cli').main();
+  const result = require('./cli').main();
+  if (result && typeof result.then === 'function') {
+    result.catch((e) => {
+      const msg = e && e.stack ? e.stack : e && e.message ? e.message : String(e);
+      console.error(msg);
+      process.exit(1);
+    });
+  }
+  return result;
 }
 
 // ---------------------------------------------------------------------------

package/lib/rdfjs.js

@@ -9,6 +9,7 @@
 
 const {
   XSD_NS,
+  LOG_NS,
   Literal: InternalLiteral,
   Iri,
   Blank,
@@ -19,6 +20,7 @@ const {
   Triple,
   Rule,
   PrefixEnv,
+  annotateQuotedGraphTerm,
   literalParts,
 } = require('./prelude');
 const { termToN3, tripleToN3 } = require('./printing');
@@ -322,6 +324,49 @@ function internalRdf12TermToRdfJs(term, factory, position) {
   return internalTermToRdfJs(term, rdfFactory, position);
 }
 
+function isDefaultGraphTerm(term) {
+  return isRdfJsTerm(term) && term.termType === 'DefaultGraph';
+}
+
+function assertDefaultGraphForRdfJsQuadTerm(term, position) {
+  if (!isDefaultGraphTerm(term.graph)) {
+    throw new TypeError(`RDF/JS Quad terms with named graphs are not supported in ${position}`);
+  }
+}
+
+function rdfJsGraphNameToInternal(term, position = 'quad.graph') {
+  assertSupportedRdfJsTerm(term, position);
+  switch (term.termType) {
+    case 'NamedNode':
+      return new Iri(term.value);
+    case 'BlankNode':
+      return new Blank(`_:${term.value}`);
+    case 'DefaultGraph':
+      return null;
+    default:
+      throw new TypeError(`Invalid RDF graph termType ${term.termType}`);
+  }
+}
+
+function internalGraphNameToRdfJs(term, factory, position = 'graph') {
+  if (term instanceof Iri || term instanceof Blank) return internalTermToRdfJs(term, factory, position);
+  return unsupportedRdfJsTerm(term, position);
+}
+
+function graphKey(term) {
+  return `${term.termType}:${term.value}`;
+}
+
+function isInternalLogNameOfTriple(triple) {
+  return (
+    triple instanceof Triple &&
+    (triple.s instanceof Iri || triple.s instanceof Blank) &&
+    triple.p instanceof Iri &&
+    triple.p.value === LOG_NS + 'nameOf' &&
+    triple.o instanceof GraphTerm
+  );
+}
+
 function assertRdfJsQuadShape(subject, predicate, object, graph) {
   if (!['NamedNode', 'BlankNode', 'Quad'].includes(subject.termType)) {
     throw new TypeError(`Invalid RDF subject termType ${subject.termType}`);
@@ -350,13 +395,22 @@ function internalTripleToRdfJsQuadInGraph(triple, graph, factory) {
 function internalTripleToRdfJsQuad(triple, factory) {
   const rdfFactory = getDataFactory(factory);
   return rdfFactory.quad(
-    internalTermToRdfJs(triple.s, rdfFactory, 'subject'),
+    internalRdf12TermToRdfJs(triple.s, rdfFactory, 'subject'),
     internalTermToRdfJs(triple.p, rdfFactory, 'predicate'),
-    internalTermToRdfJs(triple.o, rdfFactory, 'object'),
+    internalRdf12TermToRdfJs(triple.o, rdfFactory, 'object'),
     rdfFactory.defaultGraph(),
   );
 }
 
+function internalTripleToRdfJsQuads(triple, factory) {
+  const rdfFactory = getDataFactory(factory);
+  if (isInternalLogNameOfTriple(triple)) {
+    const graph = internalGraphNameToRdfJs(triple.s, rdfFactory, 'graph');
+    return (triple.o.triples || []).map((inner) => internalTripleToRdfJsQuadInGraph(inner, graph, rdfFactory));
+  }
+  return [internalTripleToRdfJsQuad(triple, rdfFactory)];
+}
+
 function escapeStringForN3(value) {
   return JSON.stringify(String(value));
 }
@@ -388,7 +442,14 @@ function rdfJsTermToN3(term, position = 'term') {
       return `${lexical}^^<${datatype}>`;
     }
     case 'Quad':
-      throw new TypeError(`Quoted triple terms are not supported in ${position}`);
+      if (String(position).endsWith('.predicate') || position === 'quad.predicate' || position === 'predicate') {
+        throw new TypeError(`Quoted triple terms are not valid RDF predicates in ${position}`);
+      }
+      assertDefaultGraphForRdfJsQuadTerm(term, position);
+      return `{ ${rdfJsTermToN3(term.subject, `${position}.subject`)} ${rdfJsTermToN3(
+        term.predicate,
+        `${position}.predicate`,
+      )} ${rdfJsTermToN3(term.object, `${position}.object`)} . }`;
     default:
       throw new TypeError(`Unsupported RDF/JS termType ${JSON.stringify(term.termType)} in ${position}`);
   }
@@ -408,8 +469,21 @@ function rdfJsTermToInternal(term, position = 'term') {
       return new InternalLiteral(rdfJsTermToN3(term, position));
     case 'DefaultGraph':
       throw new TypeError(`DefaultGraph is not a valid standalone N3 term in ${position}`);
-    case 'Quad':
-      throw new TypeError(`Quoted triple terms are not supported in ${position}`);
+    case 'Quad': {
+      if (String(position).endsWith('.predicate') || position === 'quad.predicate' || position === 'predicate') {
+        throw new TypeError(`Quoted triple terms are not valid RDF predicates in ${position}`);
+      }
+      assertDefaultGraphForRdfJsQuadTerm(term, position);
+      return annotateQuotedGraphTerm(
+        new GraphTerm([
+          new Triple(
+            rdfJsTermToInternal(term.subject, `${position}.subject`),
+            rdfJsTermToInternal(term.predicate, `${position}.predicate`),
+            rdfJsTermToInternal(term.object, `${position}.object`),
+          ),
+        ]),
+      );
+    }
     default:
       throw new TypeError(`Unsupported RDF/JS termType ${JSON.stringify(term.termType)} in ${position}`);
   }
@@ -417,22 +491,58 @@ function rdfJsTermToInternal(term, position = 'term') {
 
 function rdfJsQuadToInternalTriple(quad) {
   if (!isRdfJsQuad(quad)) throw new TypeError('Expected an RDF/JS Quad');
-  if (quad.graph.termType !== 'DefaultGraph') {
-    throw new TypeError('Named graph quads are not supported by Eyeling input; use the default graph only');
-  }
-  return new Triple(
+  const inner = new Triple(
     rdfJsTermToInternal(quad.subject, 'quad.subject'),
     rdfJsTermToInternal(quad.predicate, 'quad.predicate'),
     rdfJsTermToInternal(quad.object, 'quad.object'),
   );
+  const graph = rdfJsGraphNameToInternal(quad.graph, 'quad.graph');
+  if (!graph) return inner;
+  return new Triple(graph, new Iri(LOG_NS + 'nameOf'), annotateQuotedGraphTerm(new GraphTerm([inner])));
+}
+
+function rdfJsQuadsToInternalTriples(quads) {
+  const out = [];
+  const namedGraphs = new Map();
+
+  for (const quad of quads) {
+    if (!isRdfJsQuad(quad)) throw new TypeError('Expected an RDF/JS Quad');
+    const inner = new Triple(
+      rdfJsTermToInternal(quad.subject, 'quad.subject'),
+      rdfJsTermToInternal(quad.predicate, 'quad.predicate'),
+      rdfJsTermToInternal(quad.object, 'quad.object'),
+    );
+    const graph = rdfJsGraphNameToInternal(quad.graph, 'quad.graph');
+    if (!graph) {
+      out.push(inner);
+      continue;
+    }
+
+    const key = graphKey(quad.graph);
+    let group = namedGraphs.get(key);
+    if (!group) {
+      group = { graph, triples: [] };
+      namedGraphs.set(key, group);
+    }
+    group.triples.push(inner);
+  }
+
+  for (const { graph, triples } of namedGraphs.values()) {
+    out.push(new Triple(graph, new Iri(LOG_NS + 'nameOf'), annotateQuotedGraphTerm(new GraphTerm(triples))));
+  }
+
+  return out;
 }
 
 function rdfJsQuadToN3(quad) {
   if (!isRdfJsQuad(quad)) throw new TypeError('Expected an RDF/JS Quad');
-  if (quad.graph.termType !== 'DefaultGraph') {
-    throw new TypeError('Named graph quads are not supported by Eyeling input; use the default graph only');
-  }
-  return `${rdfJsTermToN3(quad.subject, 'quad.subject')} ${rdfJsTermToN3(quad.predicate, 'quad.predicate')} ${rdfJsTermToN3(quad.object, 'quad.object')}.`;
+  return tripleToN3(rdfJsQuadToInternalTriple(quad), PrefixEnv.newDefault());
+}
+
+function rdfJsQuadsToN3(quads) {
+  return rdfJsQuadsToInternalTriples(quads)
+    .map((triple) => tripleToN3(triple, PrefixEnv.newDefault()))
+    .join('\n');
 }
 
 function collectIterableToArray(iterable, label) {
@@ -477,6 +587,11 @@ function getPrefixesText(input) {
   return '';
 }
 
+function getN3Text(input) {
+  if (!isObject(input)) return '';
+  return typeof input.n3 === 'string' ? input.n3 : '';
+}
+
 function joinN3Sections(parts) {
   return parts
     .filter((part) => typeof part === 'string' && part.length > 0)
@@ -745,7 +860,7 @@ function appendSyncQuadFacts(doc, input) {
   const quads = collectIterableToArray(quadsInfo.value, quadsInfo.label);
   return {
     ...doc,
-    triples: doc.triples.concat(quads.map((quad) => rdfJsQuadToInternalTriple(quad))),
+    triples: doc.triples.concat(rdfJsQuadsToInternalTriples(quads)),
   };
 }
 
@@ -755,7 +870,7 @@ async function appendAsyncQuadFacts(doc, input) {
   const quads = await collectAsyncIterableToArray(quadsInfo.value, quadsInfo.label);
   return {
     ...doc,
-    triples: doc.triples.concat(quads.map((quad) => rdfJsQuadToInternalTriple(quad))),
+    triples: doc.triples.concat(rdfJsQuadsToInternalTriples(quads)),
   };
 }
 
@@ -774,13 +889,13 @@ async function normalizeParsedReasonerInputAsync(input) {
 function normalizeReasonerInputSync(input) {
   if (typeof input === 'string') return input;
   const parsed = normalizeParsedReasonerInputSync(input);
-  if (parsed) return serializeEyelingDocument(parsed);
+  const n3Text = getN3Text(input);
+  if (parsed) return joinN3Sections([n3Text, serializeEyelingDocument(parsed)]);
   if (!isObject(input)) {
     throw new TypeError(
       'Reasoner input must be an N3 string, an Eyeling AST/rule object, or an object containing RDF/JS quads plus optional rules',
     );
   }
-  if (typeof input.n3 === 'string') return input.n3;
 
   const quadsInfo = pickInputQuadIterable(input);
   const rulesText = getRulesText(input);
@@ -788,25 +903,25 @@ function normalizeReasonerInputSync(input) {
   const prefixesText = getPrefixesText(input);
 
   if (!quadsInfo) {
-    if (rulesText || factsText || prefixesText) return joinN3Sections([prefixesText, factsText, rulesText]);
+    if (n3Text || rulesText || factsText || prefixesText) return joinN3Sections([prefixesText, n3Text, factsText, rulesText]);
     throw new TypeError('Input object must provide n3 text, Eyeling AST/rule objects, or RDF/JS quads/facts/dataset');
   }
 
   const quads = collectIterableToArray(quadsInfo.value, quadsInfo.label);
-  const quadText = quads.map((quad) => rdfJsQuadToN3(quad)).join('\n');
-  return joinN3Sections([prefixesText, factsText, quadText, rulesText]);
+  const quadText = rdfJsQuadsToN3(quads);
+  return joinN3Sections([prefixesText, n3Text, factsText, quadText, rulesText]);
 }
 
 async function normalizeReasonerInputAsync(input) {
   if (typeof input === 'string') return input;
   const parsed = await normalizeParsedReasonerInputAsync(input);
-  if (parsed) return serializeEyelingDocument(parsed);
+  const n3Text = getN3Text(input);
+  if (parsed) return joinN3Sections([n3Text, serializeEyelingDocument(parsed)]);
   if (!isObject(input)) {
     throw new TypeError(
       'Reasoner input must be an N3 string, an Eyeling AST/rule object, or an object containing RDF/JS quads plus optional rules',
     );
   }
-  if (typeof input.n3 === 'string') return input.n3;
 
   const quadsInfo = pickInputQuadIterable(input);
   const rulesText = getRulesText(input);
@@ -814,13 +929,13 @@ async function normalizeReasonerInputAsync(input) {
   const prefixesText = getPrefixesText(input);
 
   if (!quadsInfo) {
-    if (rulesText || factsText || prefixesText) return joinN3Sections([prefixesText, factsText, rulesText]);
+    if (n3Text || rulesText || factsText || prefixesText) return joinN3Sections([prefixesText, n3Text, factsText, rulesText]);
     throw new TypeError('Input object must provide n3 text, Eyeling AST/rule objects, or RDF/JS quads/facts/dataset');
   }
 
   const quads = await collectAsyncIterableToArray(quadsInfo.value, quadsInfo.label);
-  const quadText = quads.map((quad) => rdfJsQuadToN3(quad)).join('\n');
-  return joinN3Sections([prefixesText, factsText, quadText, rulesText]);
+  const quadText = rdfJsQuadsToN3(quads);
+  return joinN3Sections([prefixesText, n3Text, factsText, quadText, rulesText]);
 }
 
 module.exports = {
@@ -831,8 +946,10 @@ module.exports = {
   rdfJsTermToN3,
   rdfJsQuadToN3,
   rdfJsQuadToInternalTriple,
+  rdfJsQuadsToInternalTriples,
   internalTermToRdfJs,
   internalTripleToRdfJsQuad,
+  internalTripleToRdfJsQuads,
   internalTripleToRdfJsQuadInGraph,
   normalizeParsedReasonerInputSync,
   normalizeReasonerInputSync,