eyeling 1.32.0 → 1.32.1

package/README.md

@@ -22,7 +22,7 @@ Eyeling is characterized by:
 - **Built-ins in rule bodies** — N3 programs can combine logical rules with computations such as math, string, datatype, list, time, and web-oriented predicates.
 - **Streaming RDF Messages** — supports RDF Messages streams, enabling Eyeling to fit into streaming RDF pipelines.
 - **Node.js, npm, and browser use** — run it from the command line, call it from JavaScript, or use the browser-oriented bundle.
-- **RDF-JS interoperability** — use N3 text, RDF-JS quads, datasets, or Eyeling’s own AST-level API.
+- **RDF-JS interoperability** — use N3 text, RDF-JS quads, datasets, or Eyeling’s own AST-level API, with TypeScript declarations grounded in `@rdfjs/types`.
 
 
 This README is the primary guide to using, extending, and maintaining Eyeling.
@@ -533,7 +533,7 @@ The browser entry loads `dist/browser/eyeling.browser.js` and exposes the API th
 
 ## RDF-JS integration
 
-Eyeling includes a lightweight RDF-JS DataFactory and adapters for supported RDF-JS terms and quads.
+Eyeling includes a lightweight RDF-JS DataFactory and adapters for supported RDF-JS terms and quads. Its TypeScript declarations reuse the official `@rdfjs/types` interfaces, so Eyeling quads, terms, and data factories can be passed to other RDF-JS libraries without local type casts.
 
 ```js
 const { reasonStream, rdfjs } = require('eyeling');
@@ -558,6 +558,37 @@ const result = reasonStream(input, { rdfjs: true });
 console.log(result.closureQuads);
 ```
 
+TypeScript users can use Eyeling directly with `@rdfjs/types`:
+
+```ts
+import type { DataFactory, Quad } from '@rdfjs/types';
+import { rdfjs, reasonRdfJs } from 'eyeling';
+
+const ex = 'http://example.org/';
+const factory: DataFactory<Quad> = rdfjs;
+
+const facts: Quad[] = [
+  factory.quad(
+    factory.namedNode(`${ex}Socrates`),
+    factory.namedNode(`${ex}type`),
+    factory.namedNode(`${ex}Man`),
+  ),
+];
+
+for await (const quad of reasonRdfJs({
+  quads: facts,
+  n3: `
+    @prefix : <http://example.org/> .
+    { ?x :type :Man } => { ?x :type :Mortal } .
+  `,
+})) {
+  const derived: Quad = quad;
+  console.log(derived.subject.value, derived.predicate.value, derived.object.value);
+}
+```
+
+The built-in `rdfjs` factory implements the standard RDF-JS constructors for named nodes, blank nodes, literals, default graph terms, variables, and quads, plus `fromTerm()` and `fromQuad()` clone helpers. `@rdfjs/types` is installed with Eyeling because the public declarations import it.
+
 Supported RDF-JS input terms include named nodes, blank nodes, literals, variables, default graph terms, and default-graph quads. Named-graph input quads are rejected clearly unless handled through N3/TriG compatibility mode.
 
 Use RDF-JS when you want Eyeling to sit inside a JavaScript RDF pipeline. Use raw N3 input when you need N3-only features such as quoted formulas or N3 rules represented directly in source text.
@@ -694,17 +725,20 @@ Supported operations include:
 - `dt:sameValueAs` and `dt:differentValueFrom` for value-space equality and inequality;
 - `dt:canonicalLiteral` for canonical literal production.
 
-The built-ins use strict datatype lexical validation for these checks, including exact dateTime rollover/canonicalization such as `24:00:00` normalizing to the following day. They cover RDF language strings and the OWL 2 RL-relevant XSD set: `xsd:string`, `xsd:normalizedString`, `xsd:token`, `xsd:language`, `xsd:Name`, `xsd:NCName`, `xsd:NMTOKEN`, `xsd:boolean`, `xsd:decimal`, `xsd:integer` and its bounded integer subtypes, `xsd:float`, `xsd:double`, `xsd:hexBinary`, `xsd:base64Binary`, `xsd:anyURI`, `xsd:dateTime`, and `xsd:dateTimeStamp`.
+The built-ins use strict datatype lexical validation for these checks, including exact dateTime rollover/canonicalization such as `24:00:00` normalizing to the following day. They cover RDF language strings, `rdf:PlainLiteral`, `rdf:XMLLiteral`, `rdfs:Literal`, and the OWL 2 RL-relevant XSD set: `xsd:string`, `xsd:normalizedString`, `xsd:token`, `xsd:language`, `xsd:Name`, `xsd:NCName`, `xsd:NMTOKEN`, `xsd:boolean`, `xsd:decimal`, `xsd:integer` and its bounded integer subtypes, `xsd:float`, `xsd:double`, `xsd:hexBinary`, `xsd:base64Binary`, `xsd:anyURI`, `xsd:dateTime`, and `xsd:dateTimeStamp`. Lexical validation is intentionally strict for conformance: string-derived datatypes with whitespace-collapse facets must already be written in canonical collapsed lexical form, `xsd:float` and `xsd:double` enforce finite value ranges, `xsd:anyURI` rejects spaces, unsafe delimiters, and malformed percent escapes, and XML literals must be well-formed XML fragments.
 
 Example:
 
 ```n3
 @prefix : <http://example.org/> .
 @prefix dt: <https://eyereasoner.github.io/eyeling/datatype#> .
+@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
 @prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
 
 {
   "01"^^xsd:integer dt:sameValueAs "1.0"^^xsd:decimal .
+  "hello@EN"^^rdf:PlainLiteral dt:sameValueAs "hello@en"^^rdf:PlainLiteral .
+  "<a/>"^^rdf:XMLLiteral dt:validForDatatype rdf:XMLLiteral .
   "2026-06-10T12:00:00Z"^^xsd:dateTime
     dt:sameValueAs "2026-06-10T14:00:00+02:00"^^xsd:dateTime .
   ("abc"^^xsd:integer xsd:integer) dt:validForDatatype false .

package/browser.d.ts

@@ -0,0 +1,63 @@
+export type EyelingPrefixEnv = import('eyeling').EyelingPrefixEnv;
+export type EyelingIri = import('eyeling').EyelingIri;
+export type EyelingLiteral = import('eyeling').EyelingLiteral;
+export type EyelingVar = import('eyeling').EyelingVar;
+export type EyelingBlank = import('eyeling').EyelingBlank;
+export type EyelingListTerm = import('eyeling').EyelingListTerm;
+export type EyelingOpenListTerm = import('eyeling').EyelingOpenListTerm;
+export type EyelingGraphTerm = import('eyeling').EyelingGraphTerm;
+export type EyelingTerm = import('eyeling').EyelingTerm;
+export type EyelingTriple = import('eyeling').EyelingTriple;
+export type EyelingRule = import('eyeling').EyelingRule;
+export type EyelingAstBundle = import('eyeling').EyelingAstBundle;
+export type N3Source = import('eyeling').N3Source;
+export type N3SourceListInput = import('eyeling').N3SourceListInput;
+export type RdfJsReasonInput = import('eyeling').RdfJsReasonInput;
+export type StoreOptions = import('eyeling').StoreOptions;
+export type BuiltinRegistrationContext = import('eyeling').BuiltinRegistrationContext;
+export type BuiltinHandler = import('eyeling').BuiltinHandler;
+export type ReasonStreamOptions = import('eyeling').ReasonStreamOptions;
+export type ReasonStreamResult = import('eyeling').ReasonStreamResult;
+export type FactStore = import('eyeling').FactStore;
+
+export function runAsync(
+  input: string | RdfJsReasonInput | EyelingAstBundle | N3SourceListInput,
+  opts?: ReasonStreamOptions,
+): Promise<ReasonStreamResult & { store?: FactStore }>;
+export function reasonStream(
+  input: string | RdfJsReasonInput | EyelingAstBundle | N3SourceListInput,
+  opts?: ReasonStreamOptions,
+): ReasonStreamResult;
+export function reasonRdfJs(
+  input: string | RdfJsReasonInput | EyelingAstBundle | N3SourceListInput,
+  opts?: Omit<ReasonStreamOptions, 'rdfjs' | 'onDerived'>,
+): AsyncIterable<import('@rdfjs/types').Quad>;
+
+export const INFERENCE_FUSE_EXIT_CODE: 65;
+export const rdfjs: import('eyeling').EyelingModule['rdfjs'];
+export function createFactStore(options?: string | StoreOptions | null): Promise<FactStore>;
+export function registerBuiltin(iri: string, handler: BuiltinHandler): BuiltinHandler;
+export function unregisterBuiltin(iri: string): boolean;
+export function registerBuiltinModule(mod: unknown, origin?: string): boolean;
+export function listBuiltinIris(): string[];
+export function collectOutputStringsFromFacts(facts: EyelingTriple[], prefixes: EyelingPrefixEnv): string[];
+export function prettyPrintQueryTriples(triples: EyelingTriple[], prefixes: EyelingPrefixEnv): string;
+
+export interface EyelingBrowserModule {
+  readonly version: string;
+  runAsync: typeof runAsync;
+  reasonStream: typeof reasonStream;
+  reasonRdfJs: typeof reasonRdfJs;
+  readonly INFERENCE_FUSE_EXIT_CODE: typeof INFERENCE_FUSE_EXIT_CODE;
+  rdfjs: typeof rdfjs;
+  createFactStore: typeof createFactStore;
+  registerBuiltin: typeof registerBuiltin;
+  unregisterBuiltin: typeof unregisterBuiltin;
+  registerBuiltinModule: typeof registerBuiltinModule;
+  listBuiltinIris: typeof listBuiltinIris;
+  collectOutputStringsFromFacts: typeof collectOutputStringsFromFacts;
+  prettyPrintQueryTriples: typeof prettyPrintQueryTriples;
+}
+
+declare const eyeling: EyelingBrowserModule;
+export default eyeling;

package/dist/browser/eyeling.browser.js

@@ -19,6 +19,8 @@
 
 const {
   RDF_NS,
+  RDFS_NS,
+  OWL_NS,
   XSD_NS,
   CRYPTO_NS,
   MATH_NS,
@@ -1046,6 +1048,9 @@ const XSD_HEX_BINARY_DT = XSD_NS + 'hexBinary';
 const XSD_BASE64_BINARY_DT = XSD_NS + 'base64Binary';
 const XSD_ANY_URI_DT = XSD_NS + 'anyURI';
 const RDF_LANGSTRING_DT = RDF_NS + 'langString';
+const RDF_PLAIN_LITERAL_DT = RDF_NS + 'PlainLiteral';
+const RDF_XML_LITERAL_DT = RDF_NS + 'XMLLiteral';
+const RDFS_LITERAL_DT = RDFS_NS + 'Literal';
 
 const XSD_STRING_LIKE_DTS = new Set([
   XSD_STRING_DT,
@@ -1074,6 +1079,9 @@ const XSD_INTEGER_BOUNDS = new Map([
 
 const XSD_DATATYPE_BUILTIN_DTS = new Set([
   RDF_LANGSTRING_DT,
+  RDF_PLAIN_LITERAL_DT,
+  RDF_XML_LITERAL_DT,
+  RDFS_LITERAL_DT,
   XSD_STRING_DT,
   XSD_NS + 'normalizedString',
   XSD_NS + 'token',
@@ -1095,6 +1103,11 @@ const XSD_DATATYPE_BUILTIN_DTS = new Set([
 ]);
 
 
+const XSD_FLOAT_MAX_VALUE = 3.4028234663852886e38;
+const XSD_FLOAT_MIN_POSITIVE_VALUE = 1.401298464324817e-45;
+const XSD_DOUBLE_MAX_VALUE = Number.MAX_VALUE;
+const XSD_DOUBLE_MIN_POSITIVE_VALUE = Number.MIN_VALUE;
+
 // Integer-derived datatypes from XML Schema Part 2 (and commonly used ones).
 const XSD_INTEGER_DERIVED_DTS = new Set([
   XSD_INTEGER_DT,
@@ -1153,13 +1166,31 @@ function inferDatatypeForShorthandLexical(lex) {
 
 function extractLiteralLanguageTag(litVal) {
   if (typeof litVal !== 'string' || !literalHasLangTag(litVal)) return null;
-  const lastQuote = litVal.lastIndexOf('"');
+
+  let lastQuote;
+  let quoteLen;
+  if (litVal.startsWith('\"\"\"')) {
+    lastQuote = litVal.lastIndexOf('\"\"\"');
+    quoteLen = 3;
+  } else {
+    lastQuote = litVal.lastIndexOf('"');
+    quoteLen = 1;
+  }
+
   if (lastQuote < 0) return null;
-  const after = lastQuote + 1;
+  const after = lastQuote + quoteLen;
   if (after >= litVal.length || litVal[after] !== '@') return null;
   const tag = litVal.slice(after + 1);
-  if (!/^[A-Za-z]+(?:-[A-Za-z0-9]+)*(?:--(?:ltr|rtl))?$/.test(tag)) return null;
-  return tag;
+  if (!isValidLanguageTag(tag, true)) return null;
+  return tag.toLowerCase();
+}
+
+function isValidLanguageTag(tag, allowDirectionalSuffix) {
+  if (typeof tag !== 'string') return false;
+  const pattern = allowDirectionalSuffix
+    ? /^[A-Za-z]{1,8}(?:-[A-Za-z0-9]{1,8})*(?:--(?:ltr|rtl))?$/
+    : /^[A-Za-z]{1,8}(?:-[A-Za-z0-9]{1,8})*$/;
+  return pattern.test(tag);
 }
 
 function literalLexicalValue(litVal) {
@@ -1218,17 +1249,18 @@ function canonicalFloatDoubleLex(n) {
 }
 
 function parseStringLikeDatatypeValue(lexical, dt) {
-  let value = String(lexical);
+  const value = String(lexical);
 
   if (dt === XSD_NS + 'normalizedString') {
-    value = value.replace(/[\t\n\r]/g, ' ');
+    if (/[\t\n\r]/.test(value)) return null;
   } else if (dt !== XSD_STRING_DT) {
-    value = value.replace(/[\t\n\r ]+/g, ' ').trim();
+    // String-derived datatypes with whitespace facet collapse are considered
+    // lexically valid only when the spelling is already in collapsed form.
+    if (/[\t\n\r]/.test(value) || /^ | $/.test(value) || / {2,}/.test(value)) return null;
   }
 
   if (dt === XSD_NS + 'language') {
-    if (!/^[A-Za-z]{1,8}(?:-[A-Za-z0-9]{1,8})*$/.test(value)) return null;
-    value = value.toLowerCase();
+    if (!isValidLanguageTag(value, false)) return null;
   } else if (dt === XSD_NS + 'Name') {
     if (!/^[:_\p{L}][:_\p{L}\p{N}.\-\u00B7\u0300-\u036F\u203F-\u2040]*$/u.test(value)) return null;
   } else if (dt === XSD_NS + 'NCName') {
@@ -1240,9 +1272,51 @@ function parseStringLikeDatatypeValue(lexical, dt) {
   return {
     family: 'string',
     dt,
-    value,
-    canonicalLex: value,
-    canonicalLiteral: makeDatatypeTypedLiteral(value, dt),
+    value: dt === XSD_NS + 'language' ? value.toLowerCase() : value,
+    canonicalLex: dt === XSD_NS + 'language' ? value.toLowerCase() : value,
+    canonicalLiteral: makeDatatypeTypedLiteral(dt === XSD_NS + 'language' ? value.toLowerCase() : value, dt),
+    comparable: true,
+  };
+}
+
+function parsePlainLiteralDatatypeValue(lexical) {
+  const parsed = splitPlainLiteralLexical(lexical);
+  if (!parsed) return null;
+  const canonicalLex = `${parsed.text}@${parsed.lang}`;
+  return {
+    family: 'plainLiteral',
+    dt: RDF_PLAIN_LITERAL_DT,
+    value: parsed.text,
+    lang: parsed.lang,
+    canonicalLex,
+    canonicalLiteral: makeDatatypeTypedLiteral(canonicalLex, RDF_PLAIN_LITERAL_DT),
+    comparable: true,
+  };
+}
+
+function splitPlainLiteralLexical(lexical) {
+  const s = String(lexical);
+  const at = s.lastIndexOf('@');
+  // rdf:PlainLiteral lexical forms encode the literal as text + "@" +
+  // language-tag.  The language tag may be empty, e.g. "abc@".
+  // A lexical with no separator at all, e.g. "abc", is ill-typed.
+  if (at < 0) return null;
+  const text = s.slice(0, at);
+  const lang = s.slice(at + 1);
+  if (lang !== '' && !isValidLanguageTag(lang, false)) return null;
+  return { text, lang: lang.toLowerCase() };
+}
+
+function parseXmlLiteralDatatypeValue(lexical) {
+  const s = String(lexical);
+  if (!isWellFormedXmlFragment(s)) return null;
+  const canonicalLex = s.trim();
+  return {
+    family: 'xmlLiteral',
+    dt: RDF_XML_LITERAL_DT,
+    value: canonicalLex,
+    canonicalLex,
+    canonicalLiteral: makeDatatypeTypedLiteral(canonicalLex, RDF_XML_LITERAL_DT),
     comparable: true,
   };
 }
@@ -1330,6 +1404,11 @@ function parseFloatDoubleDatatypeValue(lexical, dt) {
   const special = parseXsdFloatSpecialLex(s);
   const value = special !== null ? special : Number(s);
   if (Number.isNaN(value) && s !== 'NaN') return null;
+  if (Number.isFinite(value)) {
+    const abs = Math.abs(value);
+    if (dt === XSD_FLOAT_DT && abs > 0 && (abs > XSD_FLOAT_MAX_VALUE || abs < XSD_FLOAT_MIN_POSITIVE_VALUE)) return null;
+    if (dt === XSD_DOUBLE_DT && abs > 0 && (abs > XSD_DOUBLE_MAX_VALUE || abs < XSD_DOUBLE_MIN_POSITIVE_VALUE)) return null;
+  }
   const canonicalLex = canonicalFloatDoubleLex(value);
   return {
     family: 'numeric',
@@ -1419,7 +1498,11 @@ function parseBinaryDatatypeValue(lexical, dt) {
 
 function parseAnyUriDatatypeValue(lexical) {
   const value = String(lexical);
-  if (/[\u0000-\u001F\u007F]/.test(value)) return null;
+  if (/[^\u0021-\u007E]/.test(value) || /[<>"{}|\\^`]/.test(value)) return null;
+  for (let i = 0; i < value.length; i += 1) {
+    if (value[i] === '%' && !/^[0-9A-Fa-f]{2}$/.test(value.slice(i + 1, i + 3))) return null;
+  }
+  if (!isValidIriReferenceLexical(value)) return null;
   return {
     family: 'anyURI',
     dt: XSD_ANY_URI_DT,
@@ -1430,6 +1513,116 @@ function parseAnyUriDatatypeValue(lexical) {
   };
 }
 
+function isValidIriReferenceLexical(value) {
+  // Minimal RFC 3987/3986 structural check for IRI references.  In
+  // particular, a relative reference may not start with a colon-bearing first
+  // path segment such as ":abc"; this is the OWL 2 RL anyURI illtyped case.
+  // Empty references and fragment-only references are allowed.
+  const s = String(value);
+  if (s === '') return true;
+  if (/^[A-Za-z][A-Za-z0-9+.-]*:/.test(s)) return true; // absolute scheme
+  if (s.startsWith('//') || s.startsWith('/') || s.startsWith('?') || s.startsWith('#')) return true;
+  const cut = s.search(/[/?#]/);
+  const firstSegment = cut < 0 ? s : s.slice(0, cut);
+  return !firstSegment.includes(':');
+}
+
+function isWellFormedXmlFragment(input) {
+  const source = String(input).trim();
+  if (!source) return false;
+  const stack = [];
+  let seenElement = false;
+  let position = 0;
+
+  while (position < source.length) {
+    const open = source.indexOf('<', position);
+    if (open < 0) return stack.length === 0 && isValidXmlText(source.slice(position)) && seenElement;
+    if (!isValidXmlText(source.slice(position, open))) return false;
+
+    if (source.startsWith('<!--', open)) {
+      const close = source.indexOf('-->', open + 4);
+      if (close < 0 || source.slice(open + 4, close).includes('--')) return false;
+      position = close + 3;
+      continue;
+    }
+
+    if (source.startsWith('<![CDATA[', open)) {
+      const close = source.indexOf(']]>', open + 9);
+      if (close < 0) return false;
+      position = close + 3;
+      continue;
+    }
+
+    if (source.startsWith('<?', open)) {
+      const close = source.indexOf('?>', open + 2);
+      if (close < 0) return false;
+      position = close + 2;
+      continue;
+    }
+
+    if (source.startsWith('</', open)) {
+      const close = source.indexOf('>', open + 2);
+      if (close < 0) return false;
+      const name = source.slice(open + 2, close).trim();
+      if (!isValidXmlName(name) || stack.pop() !== name) return false;
+      position = close + 1;
+      continue;
+    }
+
+    const close = findXmlTagEnd(source, open + 1);
+    if (close < 0) return false;
+    const raw = source.slice(open + 1, close);
+    const selfClosing = /\/\s*$/.test(raw);
+    const content = selfClosing ? raw.replace(/\/\s*$/, '').trim() : raw.trim();
+    const nameMatch = /^([^\s/>]+)/.exec(content);
+    if (!nameMatch || !isValidXmlName(nameMatch[1]) || !areValidXmlAttributes(content.slice(nameMatch[0].length))) return false;
+    seenElement = true;
+    if (!selfClosing) stack.push(nameMatch[1]);
+    position = close + 1;
+  }
+
+  return stack.length === 0 && seenElement;
+}
+
+function findXmlTagEnd(source, start) {
+  let quote = null;
+  for (let i = start; i < source.length; i += 1) {
+    const ch = source[i];
+    if (quote) {
+      if (ch === quote) quote = null;
+    } else if (ch === '"' || ch === "'") {
+      quote = ch;
+    } else if (ch === '>') {
+      return i;
+    }
+  }
+  return -1;
+}
+
+function areValidXmlAttributes(source) {
+  let rest = String(source).trim();
+  const seen = new Set();
+  while (rest) {
+    const m = /^([A-Za-z_:\u0080-\uFFFF][A-Za-z0-9_.:\-\u0080-\uFFFF]*)\s*=\s*("[^"]*"|'[^']*')\s*/u.exec(rest);
+    if (!m || seen.has(m[1]) || !isValidXmlAttributeValue(m[2].slice(1, -1))) return false;
+    seen.add(m[1]);
+    rest = rest.slice(m[0].length).trim();
+  }
+  return true;
+}
+
+function isValidXmlAttributeValue(value) {
+  return !/[<]/.test(value) && isValidXmlText(value);
+}
+
+function isValidXmlText(value) {
+  return !/[<&]/.test(String(value).replace(/&(?:amp|lt|gt|quot|apos|#\d+|#x[0-9A-Fa-f]+);/g, ''));
+}
+
+function isValidXmlName(name) {
+  return /^[A-Za-z_:\u0080-\uFFFF][A-Za-z0-9_.:\-\u0080-\uFFFF]*$/u.test(name) && !/^xml$/i.test(name);
+}
+
 function isLeapYearBigInt(year) {
   if (year % 400n === 0n) return true;
   if (year % 100n === 0n) return false;
@@ -1586,11 +1779,33 @@ function parseLangStringDatatypeValue(t, lexical) {
   };
 }
 
+function literalTermDatatypeKey(t) {
+  return `${literalLexicalValue(t.value)}^^${literalDatatypeIri(t) || ''}`;
+}
+
 function parseDatatypeValueForDatatype(t, dt) {
   if (!(t instanceof Literal) || typeof dt !== 'string' || !isSupportedDatatypeIri(dt)) return null;
+
+  if (dt === RDFS_LITERAL_DT) {
+    const ownDt = literalDatatypeIri(t);
+    if (ownDt === null || !isSupportedDatatypeIri(ownDt)) return null;
+    const ownValue = parseDatatypeValueForDatatype(t, ownDt);
+    if (!ownValue) return null;
+    return {
+      family: 'literal',
+      dt: RDFS_LITERAL_DT,
+      value: literalTermDatatypeKey(t),
+      canonicalLex: literalLexicalValue(t.value),
+      canonicalLiteral: t,
+      comparable: false,
+    };
+  }
+
   const lexical = literalLexicalValue(t.value);
 
   if (dt === RDF_LANGSTRING_DT) return parseLangStringDatatypeValue(t, lexical);
+  if (dt === RDF_PLAIN_LITERAL_DT) return parsePlainLiteralDatatypeValue(lexical);
+  if (dt === RDF_XML_LITERAL_DT) return parseXmlLiteralDatatypeValue(lexical);
   if (literalHasLangTag(t.value)) return null;
   if (XSD_STRING_LIKE_DTS.has(dt)) return parseStringLikeDatatypeValue(lexical, dt);
   if (dt === XSD_BOOLEAN_DT) return parseBooleanDatatypeValue(lexical);
@@ -1616,10 +1831,11 @@ function compareDecimalExactValues(a, b) {
 
 function datatypeValuesSame(a, b) {
   if (!a || !b || !a.comparable || !b.comparable) return false;
-  if (a.family === 'langString' || b.family === 'langString') {
+  if (a.family === 'langString' || b.family === 'langString' || a.family === 'plainLiteral' || b.family === 'plainLiteral') {
     return a.family === b.family && a.value === b.value && a.lang === b.lang;
   }
   if (a.family === 'string' && b.family === 'string') return a.value === b.value;
+  if (a.family === 'xmlLiteral' && b.family === 'xmlLiteral') return a.value === b.value;
   if (a.family === 'boolean' && b.family === 'boolean') return a.value === b.value;
   if (a.family === 'anyURI' && b.family === 'anyURI') return a.value === b.value;
   if (a.family === 'binary' && b.family === 'binary') {
@@ -1646,7 +1862,9 @@ function datatypeValuesSame(a, b) {
 function datatypeValuesComparable(a, b) {
   if (!a || !b || !a.comparable || !b.comparable) return false;
   if (a.family === 'dateTime' && b.family === 'dateTime' && a.hasTimezone !== b.hasTimezone) return false;
+  if (a.family === 'numeric' && b.family === 'numeric') return true;
   if (a.family === 'langString' || b.family === 'langString') return a.family === b.family;
+  if (a.family === 'plainLiteral' || b.family === 'plainLiteral') return a.family === b.family;
   if (a.family === 'string' || b.family === 'string') return a.family === b.family;
   return a.family === b.family;
 }
@@ -1670,6 +1888,17 @@ function evalDatatypeInspectionBuiltin(g, subst, kind) {
     const dt = literalDatatypeIri(g.s);
     if (dt === null) return [];
     valueTerm = internIri(dt);
+    const out = evalBindBuiltinObject(g.o, valueTerm, subst);
+
+    // OWL 2 RL datatype rules often need common string literals to also
+    // participate in generic literal comparisons, while application rules still
+    // ask for their precise datatype explicitly.  When the datatype output is
+    // unbound, expose rdfs:Literal as an additional super-datatype answer for
+    // xsd:string and rdf:langString; bound-object calls remain strictly exact.
+    if (g.o instanceof Var && (dt === XSD_STRING_DT || dt === RDF_LANGSTRING_DT)) {
+      out.push(...evalBindBuiltinObject(g.o, internIri(RDFS_LITERAL_DT), subst));
+    }
+    return out;
   } else if (kind === 'lexicalForm') {
     valueTerm = makeStringLiteral(literalLexicalValue(g.s.value));
   } else if (kind === 'language') {
@@ -1738,6 +1967,57 @@ function evalDatatypeValueComparisonBuiltin(g, subst, same) {
   return [];
 }
 
+function evalOwlSameAsBuiltin(g, subst, facts, maxResults) {
+  const out = [];
+  const seen = new Set();
+  const limit = typeof maxResults === 'number' && maxResults > 0 ? maxResults : Infinity;
+
+  function addPair(left, right) {
+    if (out.length >= limit) return true;
+    const key = `${termFastKey ? termFastKey(left) : termToN3(left)} ${termFastKey ? termFastKey(right) : termToN3(right)}`;
+    if (seen.has(key)) return false;
+    let s2 = unifyTerm(g.s, left, subst);
+    if (s2 === null) return false;
+    s2 = unifyTerm(g.o, right, s2);
+    if (s2 === null) return false;
+    seen.add(key);
+    out.push(s2);
+    return out.length >= limit;
+  }
+
+  function addReflexive(term) {
+    return addPair(term, term);
+  }
+
+  const sameAsIri = OWL_NS + 'sameAs';
+  const differentFromIri = OWL_NS + 'differentFrom';
+
+  for (const tr of facts || []) {
+    if (tr && tr.p instanceof Iri && tr.p.value === sameAsIri) {
+      if (addPair(tr.s, tr.o)) return out;
+    }
+  }
+
+  // owl:sameAs is reflexive.  Avoid enumerating the entire active term universe
+  // for fully-unbound goals; only add the reflexive pairs that are immediately
+  // needed to detect explicit self-diversity (?x owl:differentFrom ?x).
+  if (!(g.s instanceof Var) && !(g.o instanceof Var)) {
+    if (termsEqual(g.s, g.o)) addReflexive(g.s);
+  } else if (!(g.s instanceof Var)) {
+    addReflexive(g.s);
+  } else if (!(g.o instanceof Var)) {
+    addReflexive(g.o);
+  } else {
+    for (const tr of facts || []) {
+      if (tr && tr.p instanceof Iri && tr.p.value === differentFromIri && termsEqual(tr.s, tr.o)) {
+        if (addReflexive(tr.s)) return out;
+      }
+    }
+  }
+
+  return out;
+}
+
 // ===========================================================================
 // Math builtin helpers
 // ===========================================================================
@@ -2877,6 +3157,8 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen, maxResults) {
   const pv = iriValue(g.p);
   if (pv === null) return null;
 
+  if (pv === OWL_NS + 'sameAs') return evalOwlSameAsBuiltin(g, subst, facts, maxResults);
+
   // Super restricted mode: disable *all* builtins except => / <= (log:implies / log:impliedBy)
   if (typeof getSuperRestrictedMode === 'function' && getSuperRestrictedMode()) {
     const allow1 = LOG_NS + 'implies';
@@ -5219,6 +5501,7 @@ function isBuiltinPred(p) {
   }
 
   if (__customBuiltinHandlers.has(v)) return true;
+  if (v === OWL_NS + 'sameAs') return true;
 
   return (
     v.startsWith(CRYPTO_NS) ||

package/eyeling-builtins.ttl

@@ -54,19 +54,19 @@ dt:language a ex:Builtin ; ex:kind ex:Function ;
   rdfs:comment "Extracts the language tag of an rdf:langString literal as a string literal." .
 
 dt:validForDatatype a ex:Builtin ; ex:kind ex:Test ;
-  rdfs:comment "Succeeds iff the subject literal has a lexical form accepted by the object datatype and denotes a value in that datatype's value space. Also supports tuple-to-boolean form: (literal datatype) dt:validForDatatype true/false. Supports OWL 2 RL-relevant XSD strings, booleans, numerics, binary types, anyURI, dateTime, and dateTimeStamp." .
+  rdfs:comment "Succeeds iff the subject literal has a lexical form accepted by the object datatype and denotes a value in that datatype's value space. Also supports tuple-to-boolean form: (literal datatype) dt:validForDatatype true/false. Supports OWL 2 RL-relevant RDF and XSD datatypes, including rdf:PlainLiteral, rdf:XMLLiteral, rdf:langString, rdfs:Literal, strings, booleans, numerics, binary types, anyURI, dateTime, and dateTimeStamp." .
 
 dt:invalidForDatatype a ex:Builtin ; ex:kind ex:Test ;
   rdfs:comment "Succeeds iff the object datatype is supported and the subject literal is not valid for it. Also supports tuple-to-boolean form: (literal datatype) dt:invalidForDatatype true/false." .
 
 dt:sameValueAs a ex:Builtin ; ex:kind ex:Test ;
-  rdfs:comment "Value-space equality over supported datatypes, including integer/decimal numeric equality, boolean 1/true equality, timezone-normalized dateTime equality with exact midnight rollover, string-derived whitespace facets, and binary byte equality." .
+  rdfs:comment "Value-space equality over supported datatypes, including integer/decimal numeric equality, boolean 1/true equality, rdf:PlainLiteral language-tag normalization, rdf:XMLLiteral lexical comparison after XML well-formedness checks, timezone-normalized dateTime equality with exact midnight rollover, and binary byte equality." .
 
 dt:differentValueFrom a ex:Builtin ; ex:kind ex:Test ;
   rdfs:comment "Value-space inequality over supported and comparable datatype values." .
 
 dt:canonicalLiteral a ex:Builtin ; ex:kind ex:Function ;
-  rdfs:comment "Binds/unifies the object with a canonical literal for the subject literal's datatype value, such as normalized integer, boolean, token, binary, and timezone-normalized dateTime lexicals, including 24:00:00 rollover." .
+  rdfs:comment "Binds/unifies the object with a canonical literal for the subject literal's datatype value, such as normalized integer, boolean, rdf:PlainLiteral language tags, rdf:XMLLiteral fragments, binary, and timezone-normalized dateTime lexicals, including 24:00:00 rollover." .
 
 # --- crypto: ---------------------------------------------------------