eyeling 1.29.2 → 1.30.0

package/dist/browser/eyeling.browser.js

@@ -41,6 +41,8 @@ const {
   PrefixEnv,
   literalParts,
   copyQuotedGraphMetadata,
+  isInternalBlankVarName,
+  internalBlankVarSuffix,
 } = require('./prelude');
 
 const { decodeN3StringEscapes } = require('./lexer');
@@ -143,6 +145,127 @@ function __assertBuiltinHandlerResult(iri, out) {
   }
 }
 
+function collectVarNamesInTerm(t, acc) {
+  if (t instanceof Var) {
+    acc.add(t.name);
+    return;
+  }
+  if (t instanceof ListTerm) {
+    for (const e of t.elems) collectVarNamesInTerm(e, acc);
+    return;
+  }
+  if (t instanceof OpenListTerm) {
+    for (const e of t.prefix) collectVarNamesInTerm(e, acc);
+    acc.add(t.tailVar);
+    return;
+  }
+  if (t instanceof GraphTerm) {
+    for (const tr of t.triples) collectVarNamesInTriple(tr, acc);
+  }
+}
+
+function collectVarNamesInTriple(tr, acc) {
+  collectVarNamesInTerm(tr.s, acc);
+  collectVarNamesInTerm(tr.p, acc);
+  collectVarNamesInTerm(tr.o, acc);
+}
+
+function cloneSubstWithMappedKeys(subst, keyMap, externalizeTerm) {
+  const out = Object.create(null);
+  for (const [key, val] of Object.entries(subst || {})) {
+    out[keyMap.get(key) || key] = externalizeTerm ? externalizeTerm(val) : val;
+  }
+  return out;
+}
+
+function hasInternalBlankVarInSubst(subst) {
+  for (const key of Object.keys(subst || {})) {
+    if (isInternalBlankVarName(key)) return true;
+  }
+  return false;
+}
+
+function makeCustomBuiltinPublicBridge(goal, subst) {
+  const used = new Set(Object.keys(subst || {}).filter((name) => !isInternalBlankVarName(name)));
+  collectVarNamesInTriple(goal, used);
+  for (const name of Array.from(used)) {
+    if (isInternalBlankVarName(name)) used.delete(name);
+  }
+
+  const internalNames = new Set();
+  collectVarNamesInTriple(goal, internalNames);
+  for (const key of Object.keys(subst || {})) internalNames.add(key);
+  for (const name of Array.from(internalNames)) {
+    if (!isInternalBlankVarName(name)) internalNames.delete(name);
+  }
+
+  if (internalNames.size === 0 && !hasInternalBlankVarInSubst(subst)) return null;
+
+  const internalToPublic = new Map();
+  const publicToInternal = new Map();
+
+  function allocatePublicName(internalName) {
+    const suffix = internalBlankVarSuffix(internalName) || String(internalToPublic.size + 1);
+    const base = /^[$A-Za-z_][0-9A-Za-z_]*$/u.test(`_b${suffix}`) ? `_b${suffix}` : `_b${internalToPublic.size + 1}`;
+    let name = base;
+    let n = 1;
+    while (used.has(name) || publicToInternal.has(name)) {
+      n += 1;
+      name = `${base}_${n}`;
+    }
+    used.add(name);
+    internalToPublic.set(internalName, name);
+    publicToInternal.set(name, internalName);
+    return name;
+  }
+
+  for (const name of internalNames) allocatePublicName(name);
+
+  function externalName(name) {
+    if (!isInternalBlankVarName(name)) return name;
+    return internalToPublic.get(name) || allocatePublicName(name);
+  }
+
+  function externalizeTerm(t) {
+    if (t instanceof Var) return new Var(externalName(t.name));
+    if (t instanceof ListTerm) return new ListTerm(t.elems.map(externalizeTerm));
+    if (t instanceof OpenListTerm) return new OpenListTerm(t.prefix.map(externalizeTerm), externalName(t.tailVar));
+    if (t instanceof GraphTerm) {
+      const triples = t.triples.map((tr) => new Triple(externalizeTerm(tr.s), externalizeTerm(tr.p), externalizeTerm(tr.o)));
+      return copyQuotedGraphMetadata(t, new GraphTerm(triples));
+    }
+    return t;
+  }
+
+  function internalizeTerm(t) {
+    if (t instanceof Var) return new Var(publicToInternal.get(t.name) || t.name);
+    if (t instanceof ListTerm) return new ListTerm(t.elems.map(internalizeTerm));
+    if (t instanceof OpenListTerm) return new OpenListTerm(t.prefix.map(internalizeTerm), publicToInternal.get(t.tailVar) || t.tailVar);
+    if (t instanceof GraphTerm) {
+      const triples = t.triples.map((tr) => new Triple(internalizeTerm(tr.s), internalizeTerm(tr.p), internalizeTerm(tr.o)));
+      return copyQuotedGraphMetadata(t, new GraphTerm(triples));
+    }
+    return t;
+  }
+
+  function internalizeDelta(delta) {
+    const out = Object.create(null);
+    for (const [key, val] of Object.entries(delta || {})) {
+      out[publicToInternal.get(key) || key] = internalizeTerm(val);
+    }
+    return out;
+  }
+
+  return {
+    goal: new Triple(externalizeTerm(goal.s), externalizeTerm(goal.p), externalizeTerm(goal.o)),
+    subst: cloneSubstWithMappedKeys(subst, internalToPublic, externalizeTerm),
+    internalizeResults(out) {
+      if (out == null) return out;
+      return out.map(internalizeDelta);
+    },
+  };
+}
+
 function apiTermToN3(term, prefixes = PrefixEnv.newDefault()) {
   return termToN3(term, prefixes || PrefixEnv.newDefault());
 }
@@ -242,10 +365,11 @@ function __evalRegisteredBuiltin(pv, goal, subst, facts, backRules, depth, varGe
   const handler = __customBuiltinHandlers.get(pv);
   if (typeof handler !== 'function') return null;
 
+  const bridge = makeCustomBuiltinPublicBridge(goal, subst);
   const ctx = {
     iri: pv,
-    goal,
-    subst,
+    goal: bridge ? bridge.goal : goal,
+    subst: bridge ? bridge.subst : subst,
     facts,
     backRules,
     depth,
@@ -255,7 +379,8 @@ function __evalRegisteredBuiltin(pv, goal, subst, facts, backRules, depth, varGe
   };
 
   try {
-    const out = handler(ctx);
+    const raw = handler(ctx);
+    const out = bridge ? bridge.internalizeResults(raw) : raw;
     if (out == null) return [];
     __assertBuiltinHandlerResult(pv, out);
     return out;
@@ -5965,7 +6090,7 @@ async function ingestLineBasedRdfSourceToStore(sourceLabel, store, { rdfMode = t
 }
 
 
-async function runStreamMessagesMode(sourceLabels, { rdfMode, storeName = null, storePath = null, storeClear = false } = {}) {
+async function runStreamMessagesMode(sourceLabels, { rdfMode, rdfSurfacesMode = false, storeName = null, storePath = null, storeClear = false } = {}) {
   const ordinarySourceLabels = [];
   const messageSourceLabels = [];
 
@@ -6003,6 +6128,7 @@ async function runStreamMessagesMode(sourceLabels, { rdfMode, storeName = null,
           keepSourceArtifacts: false,
           sourceLocations: false,
           rdf: rdfMode,
+          rdfSurfaces: rdfSurfacesMode,
         }),
       );
     } catch (e) {
@@ -6036,6 +6162,7 @@ async function runStreamMessagesMode(sourceLabels, { rdfMode, storeName = null,
               keepSourceArtifacts: false,
               sourceLocations: false,
               rdf: false,
+              rdfSurfaces: false,
             });
           } catch (e) {
             if (e && e.name === 'N3SyntaxError') {
@@ -6090,6 +6217,7 @@ async function main() {
       `  -h, --help                   Show this help and exit.\n` +
       `  -p, --proof                  Enable proof explanations.\n` +
       `  -r, --rdf                    Enable RDF/TriG input/output compatibility.\n` +
+      `      --rdf-surfaces           Enable RDF Surfaces %not[...%] syntax (implies --rdf).\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` +
@@ -6165,7 +6293,8 @@ async function main() {
   const showAst = argv.includes('--ast') || argv.includes('-a');
   const streamMode = argv.includes('--stream') || argv.includes('-t');
   const streamMessagesMode = argv.includes('--stream-messages');
-  const rdfMode = argv.includes('--rdf') || argv.includes('-r');
+  const rdfSurfacesMode = argv.includes('--rdf-surfaces');
+  const rdfMode = argv.includes('--rdf') || argv.includes('-r') || rdfSurfacesMode;
   const storeName = argv.__storeName || null;
   const storePath = argv.__storePath || null;
   const storeClear = argv.includes('--store-clear');
@@ -6234,7 +6363,7 @@ async function main() {
   }
 
   if (streamMessagesMode) {
-    await runStreamMessagesMode(sourceLabels, { rdfMode, storeName, storePath, storeClear });
+    await runStreamMessagesMode(sourceLabels, { rdfMode, rdfSurfacesMode, storeName, storePath, storeClear });
     return;
   }
 
@@ -6288,6 +6417,7 @@ async function main() {
                 keepSourceArtifacts: false,
                 sourceLocations: false,
                 rdf: rdfMode,
+                rdfSurfaces: rdfSurfacesMode,
               }),
             );
           } catch (e) {
@@ -6300,7 +6430,7 @@ async function main() {
         }
 
         const mergedRuleDocument = mergeParsedDocuments(parsedRuleSources);
-        const result = await engine.runStoreBacked(mergedRuleDocument, store, { rdf: rdfMode });
+        const result = await engine.runStoreBacked(mergedRuleDocument, store, { rdf: rdfMode, rdfSurfaces: rdfSurfacesMode });
         const outTriples = result.queryMode ? result.queryTriples || [] : (result.derived || []).map((df) => df.fact);
         if (result.queryMode) {
           const bodyText = engine.prettyPrintQueryTriples(outTriples, result.prefixes);
@@ -6335,6 +6465,7 @@ async function main() {
           keepSourceArtifacts: false,
           sourceLocations: engine.getProofCommentsEnabled(),
           rdf: rdfMode,
+          rdfSurfaces: rdfSurfacesMode,
         }),
       );
     } catch (e) {
@@ -6435,6 +6566,7 @@ function factsContainOutputStrings(triplesForOutput) {
       {
         proof: engine.getProofCommentsEnabled(),
         rdf: rdfMode,
+        rdfSurfaces: rdfSurfacesMode,
         store: { name: storeName, clear: storeClear, path: storePath || undefined },
       },
     );
@@ -10688,12 +10820,14 @@ function reasonStream(input, opts = {}) {
     skipUnsupportedRdfJs = false,
     builtinModules = null,
     rdf = false,
+    rdfSurfaces = false,
     sourceLabel = '<input>',
   } = opts;
 
-  const useRdfCompatibility = !!rdf;
+  const useRdfCompatibility = !!rdf || !!rdfSurfaces;
+  const useRdfSurfaces = !!rdfSurfaces;
 
-  const parsedSourceList = parseN3SourceList(input, { baseIri, rdf: useRdfCompatibility, sourceLocations: proof });
+  const parsedSourceList = parseN3SourceList(input, { baseIri, rdf: useRdfCompatibility, rdfSurfaces: useRdfSurfaces, sourceLocations: proof });
   const parsedTextInput = (!parsedSourceList && proof && typeof input === 'string')
     ? parseN3Text(input, {
         baseIri: baseIri || '',
@@ -10701,6 +10835,7 @@ function reasonStream(input, opts = {}) {
         keepSourceArtifacts: false,
         sourceLocations: true,
         rdf: useRdfCompatibility,
+        rdfSurfaces: useRdfSurfaces,
       })
     : null;
   const hasInlineN3 = input && typeof input === 'object' && !Array.isArray(input) && typeof input.n3 === 'string';
@@ -10745,6 +10880,7 @@ function reasonStream(input, opts = {}) {
       keepSourceArtifacts: false,
       sourceLocations: proof,
       rdf: useRdfCompatibility,
+      rdfSurfaces: useRdfSurfaces,
     });
     prefixes = directDoc.prefixes;
     triples = directDoc.triples;
@@ -10856,10 +10992,11 @@ async function __parseRunAsyncInput(input, opts) {
     baseIri = null,
     proof = false,
     rdf = false,
+    rdfSurfaces = false,
     sourceLabel = '<input>',
   } = opts || {};
 
-  const parsedSourceList = parseN3SourceList(input, { baseIri, rdf: !!rdf, sourceLocations: !!proof });
+  const parsedSourceList = parseN3SourceList(input, { baseIri, rdf: !!rdf || !!rdfSurfaces, rdfSurfaces: !!rdfSurfaces, sourceLocations: !!proof });
   if (parsedSourceList) return parsedSourceList;
 
   const parsedObject = await normalizeParsedReasonerInputAsync(input);
@@ -10874,7 +11011,8 @@ async function __parseRunAsyncInput(input, opts) {
     label: sourceLabel || '<input>',
     keepSourceArtifacts: false,
     sourceLocations: !!proof,
-    rdf: !!rdf,
+    rdf: !!rdf || !!rdfSurfaces,
+    rdfSurfaces: !!rdfSurfaces,
   });
 }
 
@@ -10950,7 +11088,8 @@ async function __proveGoalsAgainstStore(goals, subst, store, backRules, localFac
 async function runStoreBacked(input, store, opts = {}) {
   const parsed = parseN3SourceList(input, {
     baseIri: opts.baseIri || null,
-    rdf: !!opts.rdf,
+    rdf: !!opts.rdf || !!opts.rdfSurfaces,
+    rdfSurfaces: !!opts.rdfSurfaces,
     sourceLocations: !!opts.proof,
   }) || input;
 
@@ -10995,7 +11134,7 @@ async function runStoreBacked(input, store, opts = {}) {
   }
 
   let queryTriples = [];
-  const queryDerived = [];
+  let queryDerived = [];
   if (qrules.length) {
     for (const r of qrules) {
       const solutions = await __proveGoalsAgainstStore(r.premise || [], __emptySubst(), store, brules, triples, 0, varGen, {});
@@ -11067,7 +11206,8 @@ async function runAsync(input, opts = {}) {
   if (!storeConfig) {
     const normalizedInput = parseN3SourceList(input, {
       baseIri: runOpts.baseIri || null,
-      rdf: !!runOpts.rdf,
+      rdf: !!runOpts.rdf || !!runOpts.rdfSurfaces,
+      rdfSurfaces: !!runOpts.rdfSurfaces,
       sourceLocations: !!runOpts.proof,
     }) || (await normalizeReasonerInputAsync(input));
     return reasonStream(normalizedInput, runOpts);
@@ -12317,6 +12457,8 @@ module.exports = { tryParseFastRdfText, parseFastRdfText, parseFastRdfMessageLog
 
 'use strict';
 
+const { normalizeRdfSurfaces } = require('./rdf_surfaces');
+
 class Token {
   constructor(typ, value = null, offset = null) {
     this.typ = typ;
@@ -13657,7 +13799,9 @@ function isNumericLikeIdentifier(word) {
 
 function lex(inputText, opts = {}) {
   const rdf = !!(opts && opts.rdf);
+  const rdfSurfaces = !!(opts && opts.rdfSurfaces);
   if (rdf) inputText = normalizeRdfCompatibility(inputText);
+  if (rdfSurfaces) inputText = normalizeRdfSurfaces(inputText);
   // Avoid copying large ASCII/BMP inputs into an Array.  Array.from() is
   // only needed when the text contains surrogate pairs and we want the old
   // code-point iteration behavior for non-BMP characters.
@@ -14440,9 +14584,10 @@ function parseN3Text(text, opts = {}) {
     collectUsedPrefixes = false,
     sourceLocations = false,
     rdf = false,
+    rdfSurfaces = false,
   } = opts || {};
 
-  if (rdf) {
+  if (rdf && !rdfSurfaces) {
     const fastDoc = tryParseFastRdfText(text, { baseIri, label });
     if (fastDoc) {
       if (sourceLocations) annotateParsedSourceLocations(fastDoc, text, label);
@@ -14451,7 +14596,7 @@ function parseN3Text(text, opts = {}) {
     }
   }
 
-  const tokens = lex(text, { rdf });
+  const tokens = lex(text, { rdf, rdfSurfaces });
   const parser = new Parser(tokens);
   if (baseIri) parser.prefixes.setBase(baseIri);
   const [prefixes, triples, frules, brules, logQueryRules] = parser.parseDocument();
@@ -14650,7 +14795,8 @@ function parseN3SourceList(input, opts = {}) {
       collectUsedPrefixes: true,
       keepSourceArtifacts: !!opts.keepSourceArtifacts,
       sourceLocations: !!opts.sourceLocations,
-      rdf: !!opts.rdf,
+      rdf: !!opts.rdf || !!opts.rdfSurfaces,
+      rdfSurfaces: !!opts.rdfSurfaces,
     }),
   );
   return mergeParsedDocuments(parsed, {
@@ -15468,6 +15614,21 @@ const DT_NS = 'https://eyereasoner.github.io/eyeling/datatype#';
 const SKOLEM_NS = 'https://eyereasoner.github.io/.well-known/genid/';
 const RDF_JSON_DT = RDF_NS + 'JSON';
 
+// Private rule-lifting variable prefix used for blank nodes that appear in
+// rule-body patterns.  The prefix is intentionally not spellable in N3 input,
+// but public extension APIs should present these variables with stable,
+// ordinary names and translate them back internally.
+const INTERNAL_BLANK_VAR_PREFIX = '\uE000eyeling_b';
+
+function isInternalBlankVarName(name) {
+  return typeof name === 'string' && name.startsWith(INTERNAL_BLANK_VAR_PREFIX);
+}
+
+function internalBlankVarSuffix(name) {
+  if (!isInternalBlankVarName(name)) return '';
+  return name.slice(INTERNAL_BLANK_VAR_PREFIX.length);
+}
+
 function parseUriReferenceForResolution(uri) {
   // RFC 3986 Appendix B-style component parser, with the scheme tightened to
   // the RFC scheme grammar. Capturing delimiter presence matters: `?` with an
@@ -16171,6 +16332,9 @@ module.exports = {
   DT_NS,
   SKOLEM_NS,
   RDF_JSON_DT,
+  INTERNAL_BLANK_VAR_PREFIX,
+  isInternalBlankVarName,
+  internalBlankVarSuffix,
   resolveIriRef,
   literalParts,
   normalizeLiteralForTid,
@@ -16662,6 +16826,533 @@ module.exports = {
   needsRdf12Version,
 };
 
+  };
+  __modules["lib/rdf_surfaces.js"] = function(require, module, exports){
+/**
+ * Eyeling Reasoner — RDF Surfaces syntax normalizer
+ *
+ * Implements a small RDF Surfaces text convention inspired by Hayes' BLOGIC
+ * slides: `%not[ ... %]` surface parentheses with explicit blank mark binders
+ * such as `_:x _:y` at the beginning of a surface. The supported fragment
+ * covers slide 32, the slide 33 range shape, both slide 33 allValuesFrom
+ * shapes, and top-level fuse surfaces.
+ *
+ * The normalizer rewrites the supported fragment into ordinary Eyeling N3:
+ *   %not[ _:x P(?x) . %not[ Q(?x) . %] %]
+ * becomes:
+ *   { P(?x) . } => { Q(?x) . } .
+ *
+ * A top-level negative surface without an inner negative surface becomes an
+ * inference fuse:
+ *   %not[ _:x P(?x) . %]
+ * becomes:
+ *   { P(?x) . } => false .
+ */
+
+'use strict';
+
+function syntaxError(message, offset = null) {
+  const e = new Error(message);
+  e.name = 'N3SyntaxError';
+  if (typeof offset === 'number') e.offset = offset;
+  return e;
+}
+
+function isWs(ch) {
+  return ch != null && /\s/.test(ch);
+}
+
+
+function readStringAt(s, at) {
+  const quote = s[at];
+  let i = at;
+  let out = quote;
+  const long = s.startsWith(quote.repeat(3), i);
+  if (long) {
+    out = quote.repeat(3);
+    i += 3;
+    while (i < s.length) {
+      if (s.startsWith(quote.repeat(3), i)) {
+        out += quote.repeat(3);
+        i += 3;
+        return { text: out, end: i };
+      }
+      if (s[i] === '\\' && i + 1 < s.length) {
+        out += s.slice(i, i + 2);
+        i += 2;
+      } else {
+        out += s[i++];
+      }
+    }
+    throw syntaxError('Unterminated string literal inside RDF Surface', at);
+  }
+
+  i += 1;
+  let escaped = false;
+  while (i < s.length) {
+    const ch = s[i++];
+    out += ch;
+    if (escaped) escaped = false;
+    else if (ch === '\\') escaped = true;
+    else if (ch === quote) return { text: out, end: i };
+  }
+  throw syntaxError('Unterminated string literal inside RDF Surface', at);
+}
+
+function readIriAt(s, at) {
+  let i = at + 1;
+  let out = '<';
+  while (i < s.length) {
+    const ch = s[i++];
+    out += ch;
+    if (ch === '>') return { text: out, end: i };
+  }
+  throw syntaxError('Unterminated IRI inside RDF Surface', at);
+}
+
+function skipWsAndComments(s, at) {
+  let i = at;
+  while (i < s.length) {
+    if (isWs(s[i])) {
+      i += 1;
+      continue;
+    }
+    if (s[i] === '#') {
+      while (i < s.length && s[i] !== '\n' && s[i] !== '\r') i += 1;
+      continue;
+    }
+    break;
+  }
+  return i;
+}
+
+function readBareTokenAt(s, at) {
+  const i0 = skipWsAndComments(s, at);
+  if (i0 >= s.length) return null;
+  if (s[i0] === '<') return readIriAt(s, i0);
+  if (s[i0] === '"' || s[i0] === "'") return readStringAt(s, i0);
+  let i = i0;
+  while (i < s.length && !isWs(s[i]) && !'{}[](),;.'.includes(s[i])) i += 1;
+  if (i === i0) return null;
+  return { text: s.slice(i0, i), start: i0, end: i };
+}
+
+function readStatementSegment(s) {
+  let i = 0;
+  let depthBrace = 0;
+  let depthBracket = 0;
+  let depthParen = 0;
+  while (i < s.length) {
+    if (s.startsWith('%not[', i) && depthBrace === 0 && depthBracket === 0 && depthParen === 0) {
+      return s.slice(0, i);
+    }
+    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;
+    }
+    if (ch === '{') depthBrace += 1;
+    else if (ch === '}' && depthBrace > 0) depthBrace -= 1;
+    else if (ch === '[') depthBracket += 1;
+    else if (ch === ']' && depthBracket > 0) depthBracket -= 1;
+    else if (ch === '(') depthParen += 1;
+    else if (ch === ')' && depthParen > 0) depthParen -= 1;
+    else if (ch === '.' && depthBrace === 0 && depthBracket === 0 && depthParen === 0) return s.slice(0, i);
+    i += 1;
+  }
+  return s;
+}
+
+function tokenizeLeadingSegment(segment) {
+  const toks = [];
+  let pos = 0;
+  while (pos < segment.length) {
+    const tok = readBareTokenAt(segment, pos);
+    if (!tok) break;
+    toks.push(tok);
+    pos = tok.end;
+  }
+  return toks;
+}
+
+function extractLeadingBinders(raw) {
+  const text = String(raw || '');
+  const contentStart = skipWsAndComments(text, 0);
+  if (contentStart >= text.length) return { binders: [], text };
+
+  const segment = readStatementSegment(text.slice(contentStart));
+  const toks = tokenizeLeadingSegment(segment);
+  let leadingBlankCount = 0;
+  while (leadingBlankCount < toks.length && /^_:[A-Za-z_][A-Za-z0-9._-]*$/.test(toks[leadingBlankCount].text)) {
+    leadingBlankCount += 1;
+  }
+
+  if (leadingBlankCount === 0) return { binders: [], text };
+
+  let binderCount = 0;
+  if (toks.length >= 3) {
+    // Prefer the longest explicit binder prefix that still leaves at least a
+    // subject, predicate, and object for the first statement. This matches the
+    // BLOGIC slide convention, e.g. `%not[ _:x _:x a :C . ... %]`.
+    binderCount = Math.min(leadingBlankCount, Math.max(0, toks.length - 3));
+  } else {
+    // No own triple before a nested surface: treat the leading marks as binders.
+    binderCount = leadingBlankCount;
+  }
+
+  if (binderCount <= 0) return { binders: [], text };
+
+  const binders = toks.slice(0, binderCount).map((t) => t.text.slice(2));
+  const cut = toks[binderCount - 1].end;
+  return { binders, text: text.slice(0, contentStart) + text.slice(contentStart + cut) };
+}
+
+function splitTopLevelStatements(raw, surfaceOffset = null) {
+  const text = String(raw || '');
+  const out = [];
+  let start = 0;
+  let i = 0;
+  let depthBrace = 0;
+  let depthBracket = 0;
+  let depthParen = 0;
+
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === '"' || ch === "'") {
+      i = readStringAt(text, i).end;
+      continue;
+    }
+    if (ch === '<') {
+      i = readIriAt(text, i).end;
+      continue;
+    }
+    if (ch === '#') {
+      while (i < text.length && text[i] !== '\n' && text[i] !== '\r') i += 1;
+      continue;
+    }
+    if (ch === '{') depthBrace += 1;
+    else if (ch === '}' && depthBrace > 0) depthBrace -= 1;
+    else if (ch === '[') depthBracket += 1;
+    else if (ch === ']' && depthBracket > 0) depthBracket -= 1;
+    else if (ch === '(') depthParen += 1;
+    else if (ch === ')' && depthParen > 0) depthParen -= 1;
+    else if (ch === '.' && depthBrace === 0 && depthBracket === 0 && depthParen === 0) {
+      const stmt = text.slice(start, i).trim();
+      if (stmt) out.push(stmt);
+      start = i + 1;
+    }
+    i += 1;
+  }
+
+  const tail = text.slice(start).trim();
+  if (tail) {
+    // A raw binder-only segment is OK; any other dangling text is most likely a
+    // missing dot in the surface body.
+    if (!/^_:[A-Za-z_][A-Za-z0-9._-]*(?:\s+_:[A-Za-z_][A-Za-z0-9._-]*)*$/.test(tail)) {
+      throw syntaxError('RDF Surface statement is missing a terminating dot', surfaceOffset);
+    }
+  }
+
+  return out;
+}
+
+function readSurfaceAt(s, at) {
+  if (!s.startsWith('%not[', at)) return null;
+  let i = at + '%not['.length;
+  let current = '';
+  const segments = [];
+  const children = [];
+
+  while (i < s.length) {
+    if (s.startsWith('%]', i)) {
+      segments.push(current);
+      i += 2;
+      const raw = segments.join('\n');
+      const stripped = extractLeadingBinders(raw);
+      return {
+        type: 'not',
+        start: at,
+        end: i,
+        binders: stripped.binders,
+        statements: splitTopLevelStatements(stripped.text, at),
+        children,
+      };
+    }
+
+    if (s.startsWith('%not[', i)) {
+      segments.push(current);
+      current = '';
+      const child = readSurfaceAt(s, i);
+      children.push(child);
+      i = child.end;
+      continue;
+    }
+
+    const ch = s[i];
+    if (ch === '"' || ch === "'") {
+      const str = readStringAt(s, i);
+      current += str.text;
+      i = str.end;
+      continue;
+    }
+    if (ch === '<') {
+      const iri = readIriAt(s, i);
+      current += iri.text;
+      i = iri.end;
+      continue;
+    }
+    if (ch === '#') {
+      while (i < s.length) {
+        const c = s[i++];
+        current += c;
+        if (c === '\n' || c === '\r') break;
+      }
+      continue;
+    }
+
+    current += ch;
+    i += 1;
+  }
+
+  throw syntaxError('Unterminated RDF Surface, expected %]', at);
+}
+
+const LOG_FOR_ALL_IN_IRI = '<http://www.w3.org/2000/10/swap/log#forAllIn>';
+
+function rewriteBlankMarksWithMap(statement, labelToVarName) {
+  const map = labelToVarName instanceof Map ? labelToVarName : new Map();
+  let out = '';
+  let i = 0;
+  while (i < statement.length) {
+    const ch = statement[i];
+    if (ch === '"' || ch === "'") {
+      const str = readStringAt(statement, i);
+      out += str.text;
+      i = str.end;
+      continue;
+    }
+    if (ch === '<') {
+      const iri = readIriAt(statement, i);
+      out += iri.text;
+      i = iri.end;
+      continue;
+    }
+    if (ch === '#') {
+      while (i < statement.length) {
+        const c = statement[i++];
+        out += c;
+        if (c === '\n' || c === '\r') break;
+      }
+      continue;
+    }
+    if (statement.startsWith('_:', i)) {
+      let j = i + 2;
+      while (j < statement.length && !isWs(statement[j]) && !'{}[](),;.'.includes(statement[j])) j += 1;
+      const label = statement.slice(i + 2, j);
+      const mapped = label ? map.get(label) : null;
+      if (mapped) {
+        out += `?${mapped}`;
+        i = j;
+        continue;
+      }
+    }
+    out += ch;
+    i += 1;
+  }
+  return out.trim();
+}
+
+function formatGraphWithMap(statements, labelMap) {
+  const body = (statements || [])
+    .map((st) => rewriteBlankMarksWithMap(st, labelMap))
+    .filter(Boolean)
+    .map((st) => `  ${st} .`)
+    .join('\n');
+  return body ? `{
+${body}\n}` : '{ }';
+}
+
+function formatGraphFromRewritten(statements) {
+  const body = (statements || [])
+    .map((st) => String(st || '').trim())
+    .filter(Boolean)
+    .map((st) => `  ${st} .`)
+    .join('\n');
+  return body ? `{
+${body}\n}` : '{ }';
+}
+
+function makeVarMap(labels, prefix = '') {
+  const map = new Map();
+  for (const label of labels || []) map.set(label, `${prefix}${label}`);
+  return map;
+}
+
+function mergeVarMaps(...maps) {
+  const out = new Map();
+  for (const m of maps) {
+    for (const [k, v] of m.entries()) out.set(k, v);
+  }
+  return out;
+}
+
+function slide33ReverseAllValuesFromRule(node, inheritedMap = new Map(), extraPremises = []) {
+  const outerBinders = node.binders || [];
+  const own = node.statements || [];
+  const children = node.children || [];
+
+  if (own.length !== 0 || outerBinders.length === 0 || children.length !== 2) return null;
+
+  let bodyChild = null;
+  let headChild = null;
+  for (const child of children) {
+    const childChildren = child && child.children ? child.children : [];
+    if (childChildren.length === 1) bodyChild = child;
+    else if (childChildren.length === 0) headChild = child;
+    else return null;
+  }
+
+  if (!bodyChild || !headChild) return null;
+  if (!bodyChild.statements || bodyChild.statements.length === 0) return null;
+  if (!headChild.statements || headChild.statements.length === 0) return null;
+
+  const thenChild = bodyChild.children[0];
+  if (!thenChild || (thenChild.children && thenChild.children.length)) return null;
+  if (!thenChild.statements || thenChild.statements.length === 0) return null;
+
+  const outerMap = mergeVarMaps(inheritedMap, makeVarMap(outerBinders));
+  const witnessMap = makeVarMap(bodyChild.binders || [], '__rs_witness_');
+  const localMap = makeVarMap(bodyChild.binders || [], '__rs_');
+
+  const mappedExtra = (extraPremises || [])
+    .map((st) => rewriteBlankMarksWithMap(st, outerMap))
+    .filter(Boolean);
+  const premiseStmts = bodyChild.statements
+    .map((st) => rewriteBlankMarksWithMap(st, mergeVarMaps(outerMap, witnessMap)))
+    .filter(Boolean);
+
+  const whereGraph = formatGraphWithMap(bodyChild.statements, mergeVarMaps(outerMap, localMap));
+  const thenGraph = formatGraphWithMap(thenChild.statements, mergeVarMaps(outerMap, localMap));
+  const forAllLine = `( ${whereGraph} ${thenGraph} ) ${LOG_FOR_ALL_IN_IRI} 1`;
+
+  const premise = formatGraphFromRewritten([...mappedExtra, ...premiseStmts, forAllLine]);
+  const conclusion = formatGraphWithMap(headChild.statements, outerMap);
+  return `${premise} => ${conclusion} .`;
+}
+
+
+function translateHeadSurface(node, extraPremises, inheritedMap = new Map()) {
+  const rules = [];
+  const map = inheritedMap instanceof Map ? inheritedMap : new Map();
+  const own = node.statements || [];
+  if (own.length) {
+    rules.push(`${formatGraphWithMap(extraPremises, map)} => ${formatGraphWithMap(own, map)} .`);
+  }
+  for (const child of node.children || []) {
+    rules.push(...translateRuleSurface(child, extraPremises, map));
+  }
+  return rules;
+}
+
+function translateRuleSurface(node, extraPremises = [], inheritedMap = new Map()) {
+  const slide33Reverse = slide33ReverseAllValuesFromRule(node, inheritedMap, extraPremises);
+  if (slide33Reverse) return [slide33Reverse];
+
+  const map = mergeVarMaps(inheritedMap, makeVarMap(node.binders || []));
+  const own = node.statements || [];
+  const premise = [...(extraPremises || []), ...own];
+  const children = node.children || [];
+
+  if (children.length === 0) {
+    return own.length ? [`${formatGraphWithMap(premise, map)} => false .`] : [];
+  }
+
+  return children.flatMap((child) => translateHeadSurface(child, premise, map));
+}
+
+function translateTopLevelSurface(node) {
+  const map = makeVarMap(node.binders || []);
+  const own = node.statements || [];
+
+  if (!node.children || node.children.length === 0) {
+    return own.length ? [`${formatGraphWithMap(own, map)} => false .`] : [];
+  }
+
+  const slide33Reverse = slide33ReverseAllValuesFromRule(node);
+  if (slide33Reverse) return [slide33Reverse];
+
+  return node.children.flatMap((child) => translateHeadSurface(child, own, map));
+}
+
+function normalizeRdfSurfaces(inputText) {
+  const s = String(inputText ?? '');
+  if (!s.includes('%not[')) return s;
+
+  let out = '';
+  const generated = [];
+  let i = 0;
+  let braceDepth = 0;
+  let bracketDepth = 0;
+  let parenDepth = 0;
+
+  while (i < s.length) {
+    if (s.startsWith('%not[', i) && braceDepth === 0 && bracketDepth === 0 && parenDepth === 0) {
+      const surface = readSurfaceAt(s, i);
+      generated.push(...translateTopLevelSurface(surface));
+      i = surface.end;
+      continue;
+    }
+
+    const ch = s[i];
+    if (ch === '"' || ch === "'") {
+      const str = readStringAt(s, i);
+      out += str.text;
+      i = str.end;
+      continue;
+    }
+    if (ch === '<') {
+      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 (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;
+
+    out += ch;
+    i += 1;
+  }
+
+  if (generated.length === 0) return out;
+  const sep = out.trim() ? (out.endsWith('\n') ? '\n' : '\n\n') : '';
+  return out + sep + generated.join('\n\n') + '\n';
+}
+
+module.exports = {
+  normalizeRdfSurfaces,
+};
+
   };
   __modules["lib/rdfjs.js"] = function(require, module, exports){
 /**
@@ -17645,6 +18336,7 @@ const {
   GraphTerm,
   Triple,
   copyQuotedGraphMetadata,
+  INTERNAL_BLANK_VAR_PREFIX,
 } = require('./prelude');
 
 function liftBlankRuleVars(premise, conclusion) {
@@ -17660,10 +18352,8 @@ function liftBlankRuleVars(premise, conclusion) {
   // These variables are implementation details used to correlate one blank
   // node across the lifted rule body.  Their names must not be spellable by
   // user input; otherwise a user variable such as ?_b1 can capture the
-  // lifted blank node and leak it into the rule head.  U+E000 is a private-use
-  // code point and is not accepted by the lexer as part of a variable name.
-  const INTERNAL_BLANK_VAR_PREFIX = '\uE000eyeling_b';
-
+  // lifted blank node and leak it into the rule head.  The public custom
+  // builtin API maps these names back to ordinary-looking ?_bN variables.
   function blankToVar(label) {
     let name = mapping[label];
     if (name === undefined) {