eyeling 1.24.30 → 1.24.31

package/examples/rdf-message-flow.n3

@@ -9,28 +9,23 @@
 # Motivation
 # ----------
 # The RDF Messages draft describes an RDF Message as an RDF dataset interpreted
-# atomically, and an RDF Message Stream as an ordered sequence of such messages.
-# It also defines RDF Message Logs with explicit MESSAGE delimiters. This Eyeling
-# example keeps the same message-level discipline while staying in ordinary
-# N3/TriG that Eyeling can reason over today.
+# atomically, an RDF Message Stream as an ordered sequence of messages, and an
+# RDF Message Log as a static replayable representation of that stream.
 #
-# The companion TriG file therefore separates two layers:
+# The companion sidecar is now a true RDF Message Log: it uses
+# VERSION "1.2-messages" and MESSAGE delimiters. In RDF compatibility mode,
+# Eyeling parses those delimiters internally and materializes a replay view using
+# the eymsg: vocabulary: a stream resource, ordered envelopes, offsets,
+# next-envelope links, and one named payload graph per non-empty message.
 #
-#   1. example-local envelope facts in the default graph, such as order,
-#      processing stage, and payload graph; and
-#   2. one named graph per non-empty message payload, treated here as the RDF
-#      dataset/message that must be inspected atomically.
-#
-# The rules below deliberately do not merge all payload graphs into one global
-# graph. Instead, each observation is checked with log:includes inside the named
-# payload formula. The empty heartbeat has no payload graph but still advances
-# through the same pipeline. The next message is released only after the current
-# one reaches the sink, making the example a small back-pressure / flow-control
-# story rather than a batch merge of all input triples.
+# The rules below therefore no longer invent envelope facts in the TriG file.
+# They consume the replay view that Eyeling exposes, inspect each payload with
+# log:includes inside its own message formula, and let the empty heartbeat flow
+# through without a payload graph.
 
 @prefix : <https://eyereasoner.github.io/eyeling/examples/rdf-message-flow#>.
 @prefix flow: <https://eyereasoner.github.io/eyeling/examples/rdf-message-flow/vocab#>.
-@prefix prov: <http://www.w3.org/ns/prov#>.
+@prefix eymsg: <https://eyereasoner.github.io/eyeling/vocab/message#>.
 @prefix sosa: <http://www.w3.org/ns/sosa/>.
 @prefix xsd: <http://www.w3.org/2001/XMLSchema#>.
 @prefix math: <http://www.w3.org/2000/10/swap/math#>.
@@ -38,29 +33,49 @@
 @prefix log: <http://www.w3.org/2000/10/swap/log#>.
 @prefix string: <http://www.w3.org/2000/10/swap/string#>.
 
+# Eyeling's parser-level replay exposes the first envelope; that starts the
+# consumer-visible flow. Later envelopes are released only by the sink rule.
+{
+  ?Stream a eymsg:RDFMessageStream;
+    eymsg:firstEnvelope ?Envelope.
+} => {
+  ?Envelope :atStage :ingest.
+}.
+
+# Stream configuration is carried by the first RDF Message payload, not by a
+# hand-written sidecar envelope. The rule lifts only the threshold needed by the
+# routing rules into the ordinary reasoning context.
+{
+  ?Envelope eymsg:payloadGraph ?Payload.
+  ?Payload log:nameOf ?PayloadContext.
+  ?PayloadContext log:includes { :temperatureFlow :highThreshold ?Threshold. }.
+} => {
+  :temperatureFlow :highThreshold ?Threshold.
+}.
+
 # Stage 1: once an envelope has entered the stream, validate it.
 { ?Envelope :atStage :ingest. } => {
   ?Envelope :atStage :validate.
 }.
 
-# Stage 2: validation records that the envelope keeps an explicit message
-# boundary before the payload is interpreted.
+# Stage 2: validation records that the parser gave the reasoner an explicit
+# RDF Message boundary before the payload is interpreted.
 {
   ?Envelope :atStage :validate;
-    a flow:MessageEnvelope;
-    flow:offset ?Offset.
+    a eymsg:MessageEnvelope;
+    eymsg:offset ?Offset.
 } => {
   ?Envelope flow:boundaryExplicit true.
   ?Envelope :atStage :interpret.
 }.
 
-# Stage 3a: observation payloads are inspected inside their own payload graph.
-# This models the RDF Messages idea that messages are separate atomic datasets.
+# Stage 3a: observation payloads are inspected inside their own replayed message
+# graph. This keeps the RDF Messages default discipline: messages are atomic
+# datasets and are not silently merged.
 {
   ?Envelope :atStage :interpret;
-    flow:payloadKind :observation;
-    flow:expectedResult ?Result;
-    flow:payloadGraph ?Payload.
+    eymsg:payloadKind eymsg:nonEmpty;
+    eymsg:payloadGraph ?Payload.
   ?Payload log:nameOf ?PayloadContext.
   ?PayloadContext log:includes { ?Observation sosa:hasSimpleResult ?Result. }.
 } => {
@@ -69,10 +84,10 @@
 }.
 
 # Stage 3b: empty heartbeats contain no quads, but RDF Messages explicitly allow
-# empty messages, so the envelope still moves through the flow.
+# empty messages, so the parser-level envelope still moves through the flow.
 {
   ?Envelope :atStage :interpret;
-    flow:payloadKind :heartbeat.
+    eymsg:payloadKind eymsg:empty.
 } => {
   ?Envelope flow:emptyMessageAllowed true.
   ?Envelope :atStage :route.
@@ -112,46 +127,52 @@
   :heartbeatSink :received ?Envelope.
 }.
 
-# Continuous-flow rule: reaching the sink releases the next envelope into ingress.
-# This mirrors a consumer-visible ordered stream: later messages are not processed
-# until the earlier message has completed the pipeline.
+# Continuous-flow rule: reaching the sink releases the next replayed envelope
+# into ingress. The ordering link comes from Eyeling's internal MESSAGE replay,
+# not from the sidecar data.
 {
   ?Envelope :atStage :sink;
-    flow:nextEnvelope ?Next.
-  ?Next a flow:MessageEnvelope.
+    eymsg:nextEnvelope ?Next.
+  ?Next a eymsg:MessageEnvelope.
 } => {
   ?Envelope :releases ?Next.
   ?Next :atStage :ingest.
 }.
 
-# The Eyeling verdict is emitted only after all five envelopes have flowed
-# through ingest, validation, interpretation, routing, and sink while preserving
-# their message boundaries.
+# The verdict is emitted only after all five parser-replayed envelopes have
+# flowed through ingest, validation, interpretation, routing, and sink while
+# preserving message boundaries.
 {
-  :temperatureFlow flow:orderedEnvelopes ?Envelopes;
-    :highThreshold ?Threshold.
+  ?Stream a eymsg:RDFMessageStream;
+    eymsg:orderedEnvelopes ?Envelopes;
+    eymsg:firstEnvelope ?M1.
   ?Envelopes list:length ?Count.
-  :m001 :atStage :sink;
+  :temperatureFlow :highThreshold ?Threshold.
+  ?M1 :atStage :sink;
     flow:payloadResult ?FirstResult;
     :route :archiveSink;
-    :releases :m002.
-  :m002 :atStage :sink;
+    eymsg:nextEnvelope ?M2;
+    :releases ?M2.
+  ?M2 :atStage :sink;
     flow:payloadResult ?SecondResult;
     :route :archiveSink;
-    :releases :m003.
-  :m003 :atStage :sink;
+    eymsg:nextEnvelope ?M3;
+    :releases ?M3.
+  ?M3 :atStage :sink;
     flow:emptyMessageAllowed true;
     :route :heartbeatSink;
-    :releases :m004.
-  :m004 :atStage :sink;
+    eymsg:nextEnvelope ?M4;
+    :releases ?M4.
+  ?M4 :atStage :sink;
     flow:payloadResult ?FourthResult;
     :route :alertSink;
-    :releases :m005.
-  :m005 :atStage :sink;
+    eymsg:nextEnvelope ?M5;
+    :releases ?M5.
+  ?M5 :atStage :sink;
     flow:payloadResult ?FifthResult;
     :route :alertSink.
-  ("# rdf-message-flow\n\n## Source files\n\n- [N3 rules](../rdf-message-flow.n3)\n- [Input TriG](../input/rdf-message-flow.trig)\n\n## Answer\nContinuous RDF Message flow accepted: %d ordered message envelopes moved through the ingest → validate → interpret → route → sink pipeline. The threshold was %d, so results %s and %s were archived, the heartbeat kept the stream alive, and results %s and %s were emitted as alerts.\n\n## Explanation\nThe input is a single runnable example split across an N3 rule file and a TriG sidecar. The TriG file uses example-local envelope facts for stream order and processing state, while each named payload graph is treated as an atomic RDF Message dataset. Only :m001 starts at ingress; each envelope must reach :sink before the continuous-flow rule releases its flow:nextEnvelope. Observation payloads are inspected with log:includes inside their own payload formula, and the empty heartbeat advances without a payload graph. This keeps message boundaries visible to the reasoner instead of merging all payload triples into one global graph." ?Count ?Threshold ?FirstResult ?SecondResult ?FourthResult ?FifthResult) string:format ?Block.
+  ("# rdf-message-flow\n\n## Source files\n\n- [N3 rules](../rdf-message-flow.n3)\n- [Input RDF Message Log](../input/rdf-message-flow.trig)\n\n## Answer\nContinuous RDF Message flow accepted: %d ordered parser-replayed message envelopes moved through the ingest → validate → interpret → route → sink pipeline. The threshold was %d, so results %s and %s were archived, the empty heartbeat kept the stream alive, and results %s and %s were emitted as alerts.\n\n## Explanation\nThe input sidecar is now a true RDF Message Log using VERSION \\\"1.2-messages\\\" and MESSAGE delimiters. Eyeling parses the log internally into an eymsg: replay view with ordered envelopes, offsets, next-envelope links, and one payload graph per non-empty message. Only the first replayed envelope starts at ingress; each envelope must reach :sink before the continuous-flow rule releases its eymsg:nextEnvelope. Observation payloads are inspected with log:includes inside their own message formula, and the delimiter-only third message is replayed as an empty heartbeat. This keeps message boundaries in the parser/runtime instead of modeling them by hand in the TriG sidecar." ?Count ?Threshold ?FirstResult ?SecondResult ?FourthResult ?FifthResult) string:format ?Block.
 } => {
   :rdfMessageFlowExample log:outputString ?Block.
-  :rdfMessageFlowExample :demonstrates :ContinuousFlow, :BackPressureRelease, :AtomicMessageContext, :HeartbeatInFlow, :ThresholdRouting.
+  :rdfMessageFlowExample :demonstrates :ContinuousFlow, :BackPressureRelease, :AtomicMessageContext, :HeartbeatInFlow, :ThresholdRouting, :RDFMessageLogReplay.
 }.

package/eyeling.js

@@ -9769,6 +9769,24 @@ function stripQuotes(lex) {
 // This keeps all downstream parsing/reasoning N3-only.
 const LOG_NAME_OF_IRI = '<http://www.w3.org/2000/10/swap/log#nameOf>';
 const RDF_REIFIES_IRI = '<http://www.w3.org/1999/02/22-rdf-syntax-ns#reifies>';
+const RDF_TYPE_IRI = '<http://www.w3.org/1999/02/22-rdf-syntax-ns#type>';
+const XSD_INTEGER_IRI = '<http://www.w3.org/2001/XMLSchema#integer>';
+const EYMSG_NS = 'https://eyereasoner.github.io/eyeling/vocab/message#';
+const EYMSG = Object.freeze({
+  RDFMessageStream: `<${EYMSG_NS}RDFMessageStream>`,
+  MessageEnvelope: `<${EYMSG_NS}MessageEnvelope>`,
+  envelope: `<${EYMSG_NS}envelope>`,
+  firstEnvelope: `<${EYMSG_NS}firstEnvelope>`,
+  lastEnvelope: `<${EYMSG_NS}lastEnvelope>`,
+  orderedEnvelopes: `<${EYMSG_NS}orderedEnvelopes>`,
+  messageCount: `<${EYMSG_NS}messageCount>`,
+  offset: `<${EYMSG_NS}offset>`,
+  nextEnvelope: `<${EYMSG_NS}nextEnvelope>`,
+  payloadGraph: `<${EYMSG_NS}payloadGraph>`,
+  payloadKind: `<${EYMSG_NS}payloadKind>`,
+  empty: `<${EYMSG_NS}empty>`,
+  nonEmpty: `<${EYMSG_NS}nonEmpty>`,
+});
 
 function normalizeRdfCompatibility(inputText) {
   let text = String(inputText ?? '');
@@ -9779,10 +9797,11 @@ function normalizeRdfCompatibility(inputText) {
   // plausible top-level TriG named graph block.
   const hasTripleTerms = text.includes('<<');
   const hasVersionDirective = /^\s*(?:@version|VERSION)\s+(["'])1\.2\1\s*\.?\s*(?:#.*)?$/im.test(text);
+  const hasMessageVersionDirective = /^\s*(?:@version|VERSION)\s+(["'])(?:1\.1|1\.2|1\.2-basic)-messages\1\s*\.?\s*(?:#.*)?$/im.test(text);
   const hasNamedGraphCandidate = /(?:^|[.\r\n])\s*(?:GRAPH\s+)?(?:<[^>\r\n]*>|_:[A-Za-z][A-Za-z0-9_-]*|[A-Za-z][A-Za-z0-9_-]*:[^\s{};,.()[\]]*)\s*\{/m.test(text);
   const hasAnnotationSyntax = /(?:^|\s)~\s*(?:<|_:[A-Za-z]|[A-Za-z][A-Za-z0-9_-]*:|\{\|)|\{\|/.test(text);
 
-  if (!hasTripleTerms && !hasVersionDirective && !hasNamedGraphCandidate && !hasAnnotationSyntax) return text;
+  if (!hasTripleTerms && !hasVersionDirective && !hasMessageVersionDirective && !hasNamedGraphCandidate && !hasAnnotationSyntax) return text;
 
   function isWordChar(ch) {
     return ch != null && /[A-Za-z0-9_:-]/.test(ch);
@@ -10136,7 +10155,7 @@ function normalizeRdfCompatibility(inputText) {
   }
 
   function stripVersionDirectives(s) {
-    return s.replace(/^\s*(?:@version|VERSION)\s+(["'])1\.2\1\s*\.?\s*(?:#.*)?$/gim, '');
+    return s.replace(/^\s*(?:@version|VERSION)\s+(["'])(?:1\.1|1\.2|1\.2-basic)(?:-messages)?\1\s*\.?\s*(?:#.*)?$/gim, '');
   }
 
   function skipWsAndComments(s, at) {
@@ -10290,10 +10309,270 @@ function normalizeRdfCompatibility(inputText) {
     return out;
   }
 
+
+  function isOnlyWhitespaceAndComments(s) {
+    return skipWsAndComments(s, 0) >= s.length;
+  }
+
+
+  function skipOldStyleDirective(s, at) {
+    let i = at;
+    while (i < s.length) {
+      const ch = s[i];
+      if (ch === '"' || ch === "'") {
+        i = readStringAt(s, i).end;
+        continue;
+      }
+      if (ch === '<') {
+        i = readIriAt(s, i).end;
+        continue;
+      }
+      if (ch === '#') {
+        while (i < s.length && s[i] !== '\n' && s[i] !== '\r') i += 1;
+        continue;
+      }
+      i += 1;
+      if (ch === '.') return i;
+    }
+    return i;
+  }
+
+  function stripDirectivesAndCommentsForEmptiness(s) {
+    let out = '';
+    let i = 0;
+    let statementStart = true;
+    while (i < s.length) {
+      const ch = s[i];
+      if (ch === '"' || ch === "'") {
+        const str = readStringAt(s, i);
+        out += str.text;
+        i = str.end;
+        statementStart = false;
+        continue;
+      }
+      if (ch === '<') {
+        const iri = readIriAt(s, i);
+        out += iri.text;
+        i = iri.end;
+        statementStart = false;
+        continue;
+      }
+      if (ch === '#') {
+        while (i < s.length && s[i] !== '\n' && s[i] !== '\r') i += 1;
+        statementStart = true;
+        continue;
+      }
+      if (statementStart) {
+        const start = skipWsAndComments(s, i);
+        out += s.slice(i, start);
+        i = start;
+        if (startsWordAt(s, 'PREFIX', i) || startsWordAt(s, 'BASE', i) || startsWordAt(s, 'VERSION', i)) {
+          while (i < s.length && s[i] !== '\n' && s[i] !== '\r') i += 1;
+          statementStart = true;
+          continue;
+        }
+        if (s[i] === '@') {
+          const lower = s.slice(i, i + 9).toLowerCase();
+          if (lower.startsWith('@prefix') || lower.startsWith('@base') || lower.startsWith('@version')) {
+            i = skipOldStyleDirective(s, i);
+            statementStart = true;
+            continue;
+          }
+        }
+      }
+      out += ch;
+      if (ch === '.' || ch === '}' || ch === '\n' || ch === '\r') statementStart = true;
+      else if (!/\s/.test(ch)) statementStart = false;
+      i += 1;
+    }
+    return out;
+  }
+
+  function simpleHashText(s) {
+    let h = 0x811c9dc5;
+    for (let i = 0; i < s.length; i += 1) {
+      h ^= s.charCodeAt(i);
+      h = Math.imul(h, 0x01000193) >>> 0;
+    }
+    return h.toString(16).padStart(8, '0');
+  }
+
+  function rewriteMessageBlankLabels(s, messageIndex) {
+    let out = '';
+    let i = 0;
+    const prefix = `_:eyeling_m${String(messageIndex).padStart(3, '0')}_`;
+    while (i < s.length) {
+      const ch = s[i];
+      if (ch === '"' || ch === "'") {
+        const str = readStringAt(s, i);
+        out += str.text;
+        i = str.end;
+        continue;
+      }
+      if (ch === '<' && !s.startsWith('<<', i)) {
+        const iri = readIriAt(s, i);
+        out += iri.text;
+        i = iri.end;
+        continue;
+      }
+      if (ch === '#') {
+        while (i < s.length) {
+          const c = s[i++];
+          out += c;
+          if (c === '\n' || c === '\r') break;
+        }
+        continue;
+      }
+      if (s.startsWith('_:', i)) {
+        let j = i + 2;
+        while (j < s.length && !/\s/.test(s[j]) && !'{}[](),;.'.includes(s[j])) j += 1;
+        const label = s.slice(i + 2, j);
+        if (label) {
+          out += prefix + label.replace(/[^A-Za-z0-9_]/g, '_');
+          i = j;
+          continue;
+        }
+      }
+      out += ch;
+      i += 1;
+    }
+    return out;
+  }
+
+  function findMessageDirectiveAt(s, at) {
+    if (startsWordAt(s, 'MESSAGE', at)) return { start: at, end: at + 'MESSAGE'.length };
+    if (s.slice(at, at + 8).toLowerCase() === '@message' && !isWordChar(s[at + 8])) {
+      let end = at + 8;
+      end = skipWsAndComments(s, end);
+      if (s[end] === '.') end += 1;
+      return { start: at, end };
+    }
+    return null;
+  }
+
+  function splitRdfMessageLog(s) {
+    const chunks = [];
+    let i = 0;
+    let start = 0;
+    let braceDepth = 0;
+    let bracketDepth = 0;
+    let parenDepth = 0;
+    let statementStart = true;
+    let sawDelimiter = false;
+
+    while (i < s.length) {
+      const ch = s[i];
+      if (ch === '"' || ch === "'") {
+        i = readStringAt(s, i).end;
+        statementStart = false;
+        continue;
+      }
+      if (ch === '<' && !s.startsWith('<<', i)) {
+        i = readIriAt(s, i).end;
+        statementStart = false;
+        continue;
+      }
+      if (ch === '#') {
+        while (i < s.length && s[i] !== '\n' && s[i] !== '\r') i += 1;
+        statementStart = true;
+        continue;
+      }
+      if (statementStart && braceDepth === 0 && bracketDepth === 0 && parenDepth === 0) {
+        const termStart = skipWsAndComments(s, i);
+        const msg = findMessageDirectiveAt(s, termStart);
+        if (msg) {
+          chunks.push(s.slice(start, termStart));
+          start = msg.end;
+          i = msg.end;
+          statementStart = true;
+          sawDelimiter = true;
+          continue;
+        }
+        if (termStart !== i) {
+          i = termStart;
+          continue;
+        }
+      }
+      if (ch === '{') braceDepth += 1;
+      else if (ch === '}' && braceDepth > 0) braceDepth -= 1;
+      else if (ch === '[') bracketDepth += 1;
+      else if (ch === ']' && bracketDepth > 0) bracketDepth -= 1;
+      else if (ch === '(') parenDepth += 1;
+      else if (ch === ')' && parenDepth > 0) parenDepth -= 1;
+
+      if (ch === '.' && braceDepth === 0 && bracketDepth === 0 && parenDepth === 0) statementStart = true;
+      else if (ch === '\n' || ch === '\r') statementStart = true;
+      else if (!/\s/.test(ch)) statementStart = false;
+      i += 1;
+    }
+
+    const tail = s.slice(start);
+    if (!sawDelimiter || !isOnlyWhitespaceAndComments(tail)) chunks.push(tail);
+    return chunks;
+  }
+
+  function normalizeMessageChunk(chunk, messageIndex) {
+    let body = String(chunk || '');
+    if (hasTripleTerms || body.includes('<<')) body = convertTripleTerms(body);
+    if (hasAnnotationSyntax || /(?:^|\s)~\s*(?:<|_:[A-Za-z]|[A-Za-z][A-Za-z0-9_-]*:|\{\|)|\{\|/.test(body)) {
+      body = convertAnnotations(body);
+    }
+    body = normalizeNamedGraphs(body);
+    body = rewriteMessageBlankLabels(body, messageIndex);
+    return body.trim();
+  }
+
+  function messageChunkHasRdf(body) {
+    return !isOnlyWhitespaceAndComments(stripDirectivesAndCommentsForEmptiness(body));
+  }
+
+  function normalizeRdfMessageLog(s) {
+    const withoutVersion = stripVersionDirectives(s);
+    const chunks = splitRdfMessageLog(withoutVersion);
+    const hash = simpleHashText(s);
+    const base = `urn:eyeling:message-log:${hash}`;
+    const stream = `<${base}#stream>`;
+    const envelopeIris = chunks.map((unused, idx) => `<${base}#m${String(idx + 1).padStart(3, '0')}>`);
+    const payloadIris = chunks.map((unused, idx) => `<${base}#m${String(idx + 1).padStart(3, '0')}/payload>`);
+    const out = [];
+
+    out.push(`${stream} ${RDF_TYPE_IRI} ${EYMSG.RDFMessageStream} .`);
+    out.push(`${stream} ${EYMSG.messageCount} "${chunks.length}"^^${XSD_INTEGER_IRI} .`);
+    if (envelopeIris.length) {
+      out.push(`${stream} ${EYMSG.orderedEnvelopes} (${envelopeIris.join(' ')}) .`);
+      out.push(`${stream} ${EYMSG.firstEnvelope} ${envelopeIris[0]} .`);
+      out.push(`${stream} ${EYMSG.lastEnvelope} ${envelopeIris[envelopeIris.length - 1]} .`);
+    }
+
+    for (let idx = 0; idx < chunks.length; idx += 1) {
+      const n = idx + 1;
+      const envelope = envelopeIris[idx];
+      const payload = payloadIris[idx];
+      const body = normalizeMessageChunk(chunks[idx], n);
+      const hasBody = messageChunkHasRdf(body);
+
+      out.push(`${stream} ${EYMSG.envelope} ${envelope} .`);
+      out.push(`${envelope} ${RDF_TYPE_IRI} ${EYMSG.MessageEnvelope} .`);
+      out.push(`${envelope} ${EYMSG.offset} "${n}"^^${XSD_INTEGER_IRI} .`);
+      out.push(`${envelope} ${EYMSG.payloadKind} ${hasBody ? EYMSG.nonEmpty : EYMSG.empty} .`);
+      if (idx + 1 < envelopeIris.length) out.push(`${envelope} ${EYMSG.nextEnvelope} ${envelopeIris[idx + 1]} .`);
+      if (hasBody) {
+        out.push(`${envelope} ${EYMSG.payloadGraph} ${payload} .`);
+        out.push(`${payload} ${LOG_NAME_OF_IRI} {`);
+        out.push(body);
+        out.push(`} .`);
+      }
+    }
+
+    return out.join('\n') + '\n';
+  }
+
+  if (hasMessageVersionDirective) return normalizeRdfMessageLog(text);
+
   if (hasTripleTerms) text = convertTripleTerms(text);
   if (hasAnnotationSyntax) text = convertAnnotations(text);
-  if (hasVersionDirective) text = stripVersionDirectives(text);
-  if (hasVersionDirective || hasNamedGraphCandidate) text = normalizeNamedGraphs(text);
+  if (hasVersionDirective || hasMessageVersionDirective) text = stripVersionDirectives(text);
+  if (hasVersionDirective || hasMessageVersionDirective || hasNamedGraphCandidate) text = normalizeNamedGraphs(text);
   return text;
 }