eyeling 1.9.1 → 1.9.3

package/eyeling.js

@@ -624,2193 +624,1870 @@ class DerivedFact {
     }
 }
 // ===========================================================================
-// LEXER
+// Blank-node lifting and Skolemization
 // ===========================================================================
-class Token {
-    constructor(typ, value = null, offset = null) {
-        this.typ = typ;
-        this.value = value;
-        // Codepoint offset in the original source (Array.from(text) index).
-        this.offset = offset;
-    }
-    toString() {
-        const loc = typeof this.offset === 'number' ? `@${this.offset}` : '';
-        if (this.value == null)
-            return `Token(${this.typ}${loc})`;
-        return `Token(${this.typ}${loc}, ${JSON.stringify(this.value)})`;
+function liftBlankRuleVars(premise, conclusion) {
+    function convertTerm(t, mapping, counter) {
+        if (t instanceof Blank) {
+            const label = t.label;
+            if (!mapping.hasOwnProperty(label)) {
+                counter[0] += 1;
+                mapping[label] = `_b${counter[0]}`;
+            }
+            return new Var(mapping[label]);
+        }
+        if (t instanceof ListTerm) {
+            return new ListTerm(t.elems.map((e) => convertTerm(e, mapping, counter)));
+        }
+        if (t instanceof OpenListTerm) {
+            return new OpenListTerm(t.prefix.map((e) => convertTerm(e, mapping, counter)), t.tailVar);
+        }
+        if (t instanceof GraphTerm) {
+            const triples = t.triples.map((tr) => new Triple(convertTerm(tr.s, mapping, counter), convertTerm(tr.p, mapping, counter), convertTerm(tr.o, mapping, counter)));
+            return new GraphTerm(triples);
+        }
+        return t;
     }
-}
-class N3SyntaxError extends SyntaxError {
-    constructor(message, offset = null) {
-        super(message);
-        this.name = 'N3SyntaxError';
-        this.offset = offset;
+    function convertTriple(tr, mapping, counter) {
+        return new Triple(convertTerm(tr.s, mapping, counter), convertTerm(tr.p, mapping, counter), convertTerm(tr.o, mapping, counter));
     }
+    const mapping = {};
+    const counter = [0];
+    const newPremise = premise.map((tr) => convertTriple(tr, mapping, counter));
+    return [newPremise, conclusion];
 }
-function isWs(c) {
-    return /\s/.test(c);
-}
-function isNameChar(c) {
-    return /[0-9A-Za-z_\-:]/.test(c);
-}
-function decodeN3StringEscapes(s) {
-    let out = '';
-    for (let i = 0; i < s.length; i++) {
-        const c = s[i];
-        if (c !== '\\') {
-            out += c;
-            continue;
-        }
-        if (i + 1 >= s.length) {
-            out += '\\';
-            continue;
+// Skolemization for blank nodes that occur explicitly in a rule head.
+//
+// IMPORTANT: we must be *stable per rule firing*, otherwise a rule whose
+// premises stay true would keep generating fresh _:sk_N blank nodes on every
+// outer fixpoint iteration (non-termination once we do strict duplicate checks).
+//
+// We achieve this by optionally keying head-blank allocations by a "firingKey"
+// (usually derived from the instantiated premises and rule index) and caching
+// them in a run-global map.
+function skolemizeTermForHeadBlanks(t, headBlankLabels, mapping, skCounter, firingKey, globalMap) {
+    if (t instanceof Blank) {
+        const label = t.label;
+        // Only skolemize blanks that occur explicitly in the rule head
+        if (!headBlankLabels || !headBlankLabels.has(label)) {
+            return t; // this is a data blank (e.g. bound via ?X), keep it
         }
-        const e = s[++i];
-        switch (e) {
-            case 't':
-                out += '\t';
-                break;
-            case 'n':
-                out += '\n';
-                break;
-            case 'r':
-                out += '\r';
-                break;
-            case 'b':
-                out += '\b';
-                break;
-            case 'f':
-                out += '\f';
-                break;
-            case '"':
-                out += '"';
-                break;
-            case "'":
-                out += "'";
-                break;
-            case '\\':
-                out += '\\';
-                break;
-            case 'u': {
-                const hex = s.slice(i + 1, i + 5);
-                if (/^[0-9A-Fa-f]{4}$/.test(hex)) {
-                    out += String.fromCharCode(parseInt(hex, 16));
-                    i += 4;
-                }
-                else {
-                    out += '\\u';
+        if (!mapping.hasOwnProperty(label)) {
+            // If we have a global cache keyed by firingKey, use it to ensure
+            // deterministic blank IDs for the same rule+substitution instance.
+            if (globalMap && firingKey) {
+                const gk = `${firingKey}|${label}`;
+                let sk = globalMap.get(gk);
+                if (!sk) {
+                    const idx = skCounter[0];
+                    skCounter[0] += 1;
+                    sk = `_:sk_${idx}`;
+                    globalMap.set(gk, sk);
                 }
-                break;
+                mapping[label] = sk;
             }
-            case 'U': {
-                const hex = s.slice(i + 1, i + 9);
-                if (/^[0-9A-Fa-f]{8}$/.test(hex)) {
-                    const cp = parseInt(hex, 16);
-                    if (cp >= 0 && cp <= 0x10ffff)
-                        out += String.fromCodePoint(cp);
-                    else
-                        out += '\\U' + hex;
-                    i += 8;
-                }
-                else {
-                    out += '\\U';
-                }
-                break;
+            else {
+                const idx = skCounter[0];
+                skCounter[0] += 1;
+                mapping[label] = `_:sk_${idx}`;
             }
-            default:
-                // preserve unknown escapes
-                out += '\\' + e;
         }
+        return new Blank(mapping[label]);
     }
-    return out;
-}
-function lex(inputText) {
-    const chars = Array.from(inputText);
-    const n = chars.length;
-    let i = 0;
-    const tokens = [];
-    function peek(offset = 0) {
-        const j = i + offset;
-        return j >= 0 && j < n ? chars[j] : null;
+    if (t instanceof ListTerm) {
+        return new ListTerm(t.elems.map((e) => skolemizeTermForHeadBlanks(e, headBlankLabels, mapping, skCounter, firingKey, globalMap)));
     }
-    while (i < n) {
-        let c = peek();
-        if (c === null)
-            break;
-        // 1) Whitespace
-        if (isWs(c)) {
-            i++;
-            continue;
+    if (t instanceof OpenListTerm) {
+        return new OpenListTerm(t.prefix.map((e) => skolemizeTermForHeadBlanks(e, headBlankLabels, mapping, skCounter, firingKey, globalMap)), t.tailVar);
+    }
+    if (t instanceof GraphTerm) {
+        return new GraphTerm(t.triples.map((tr) => skolemizeTripleForHeadBlanks(tr, headBlankLabels, mapping, skCounter, firingKey, globalMap)));
+    }
+    return t;
+}
+function skolemizeTripleForHeadBlanks(tr, headBlankLabels, mapping, skCounter, firingKey, globalMap) {
+    return new Triple(skolemizeTermForHeadBlanks(tr.s, headBlankLabels, mapping, skCounter, firingKey, globalMap), skolemizeTermForHeadBlanks(tr.p, headBlankLabels, mapping, skCounter, firingKey, globalMap), skolemizeTermForHeadBlanks(tr.o, headBlankLabels, mapping, skCounter, firingKey, globalMap));
+}
+// ===========================================================================
+// Alpha equivalence helpers
+// ===========================================================================
+function termsEqual(a, b) {
+    if (a === b)
+        return true;
+    if (!a || !b)
+        return false;
+    if (a.constructor !== b.constructor)
+        return false;
+    if (a instanceof Iri)
+        return a.value === b.value;
+    if (a instanceof Literal) {
+        if (a.value === b.value)
+            return true;
+        // Plain "abc" == "abc"^^xsd:string (but not language-tagged strings)
+        if (literalsEquivalentAsXsdString(a.value, b.value))
+            return true;
+        // Keep in sync with unifyTerm(): numeric-value equality, datatype-aware.
+        const ai = parseNumericLiteralInfo(a);
+        const bi = parseNumericLiteralInfo(b);
+        if (ai && bi) {
+            // Same datatype => compare values
+            if (ai.dt === bi.dt) {
+                if (ai.kind === 'bigint' && bi.kind === 'bigint')
+                    return ai.value === bi.value;
+                const an = ai.kind === 'bigint' ? Number(ai.value) : ai.value;
+                const bn = bi.kind === 'bigint' ? Number(bi.value) : bi.value;
+                return !Number.isNaN(an) && !Number.isNaN(bn) && an === bn;
+            }
         }
-        // 2) Comments starting with '#'
-        if (c === '#') {
-            while (i < n && chars[i] !== '\n' && chars[i] !== '\r')
-                i++;
-            continue;
+        return false;
+    }
+    if (a instanceof Var)
+        return a.name === b.name;
+    if (a instanceof Blank)
+        return a.label === b.label;
+    if (a instanceof ListTerm) {
+        if (a.elems.length !== b.elems.length)
+            return false;
+        for (let i = 0; i < a.elems.length; i++) {
+            if (!termsEqual(a.elems[i], b.elems[i]))
+                return false;
         }
-        // 3) Two-character operators: => and <=
-        if (c === '=') {
-            if (peek(1) === '>') {
-                tokens.push(new Token('OpImplies', null, i));
-                i += 2;
-                continue;
-            }
-            else {
-                // N3 syntactic sugar: '=' means owl:sameAs
-                tokens.push(new Token('Equals', null, i));
-                i += 1;
-                continue;
-            }
+        return true;
+    }
+    if (a instanceof OpenListTerm) {
+        if (a.tailVar !== b.tailVar)
+            return false;
+        if (a.prefix.length !== b.prefix.length)
+            return false;
+        for (let i = 0; i < a.prefix.length; i++) {
+            if (!termsEqual(a.prefix[i], b.prefix[i]))
+                return false;
         }
-        if (c === '<') {
-            if (peek(1) === '=') {
-                tokens.push(new Token('OpImpliedBy', null, i));
-                i += 2;
-                continue;
-            }
-            // N3 predicate inversion: "<-" (swap subject/object for this predicate)
-            if (peek(1) === '-') {
-                tokens.push(new Token('OpPredInvert', null, i));
-                i += 2;
-                continue;
-            }
-            // Otherwise IRIREF <...>
-            const start = i;
-            i++; // skip '<'
-            const iriChars = [];
-            while (i < n && chars[i] !== '>') {
-                iriChars.push(chars[i]);
-                i++;
-            }
-            if (i >= n || chars[i] !== '>') {
-                throw new N3SyntaxError('Unterminated IRI <...>', start);
+        return true;
+    }
+    if (a instanceof GraphTerm) {
+        return alphaEqGraphTriples(a.triples, b.triples);
+    }
+    return false;
+}
+function termsEqualNoIntDecimal(a, b) {
+    if (a === b)
+        return true;
+    if (!a || !b)
+        return false;
+    if (a.constructor !== b.constructor)
+        return false;
+    if (a instanceof Iri)
+        return a.value === b.value;
+    if (a instanceof Literal) {
+        if (a.value === b.value)
+            return true;
+        // Plain "abc" == "abc"^^xsd:string (but not language-tagged)
+        if (literalsEquivalentAsXsdString(a.value, b.value))
+            return true;
+        // Numeric equality ONLY when datatypes agree (no integer<->decimal here)
+        const ai = parseNumericLiteralInfo(a);
+        const bi = parseNumericLiteralInfo(b);
+        if (ai && bi && ai.dt === bi.dt) {
+            // integer: exact bigint
+            if (ai.kind === 'bigint' && bi.kind === 'bigint')
+                return ai.value === bi.value;
+            // decimal: compare exactly via num/scale if possible
+            if (ai.dt === XSD_NS + 'decimal') {
+                const da = parseXsdDecimalToBigIntScale(ai.lexStr);
+                const db = parseXsdDecimalToBigIntScale(bi.lexStr);
+                if (da && db) {
+                    const scale = Math.max(da.scale, db.scale);
+                    const na = da.num * pow10n(scale - da.scale);
+                    const nb = db.num * pow10n(scale - db.scale);
+                    return na === nb;
+                }
             }
-            i++; // skip '>'
-            const iri = iriChars.join('');
-            tokens.push(new Token('IriRef', iri, start));
-            continue;
+            // double/float-ish: JS number (same as your normal same-dt path)
+            const an = ai.kind === 'bigint' ? Number(ai.value) : ai.value;
+            const bn = bi.kind === 'bigint' ? Number(bi.value) : bi.value;
+            return !Number.isNaN(an) && !Number.isNaN(bn) && an === bn;
         }
-        // 4) Path + datatype operators: !, ^, ^^
-        if (c === '!') {
-            tokens.push(new Token('OpPathFwd', null, i));
-            i += 1;
-            continue;
+        return false;
+    }
+    if (a instanceof Var)
+        return a.name === b.name;
+    if (a instanceof Blank)
+        return a.label === b.label;
+    if (a instanceof ListTerm) {
+        if (a.elems.length !== b.elems.length)
+            return false;
+        for (let i = 0; i < a.elems.length; i++) {
+            if (!termsEqualNoIntDecimal(a.elems[i], b.elems[i]))
+                return false;
         }
-        if (c === '^') {
-            if (peek(1) === '^') {
-                tokens.push(new Token('HatHat', null, i));
-                i += 2;
-                continue;
-            }
-            tokens.push(new Token('OpPathRev', null, i));
-            i += 1;
-            continue;
+        return true;
+    }
+    if (a instanceof OpenListTerm) {
+        if (a.tailVar !== b.tailVar)
+            return false;
+        if (a.prefix.length !== b.prefix.length)
+            return false;
+        for (let i = 0; i < a.prefix.length; i++) {
+            if (!termsEqualNoIntDecimal(a.prefix[i], b.prefix[i]))
+                return false;
         }
-        // 5) Single-character punctuation
-        if ('{}()[];,.'.includes(c)) {
-            const mapping = {
-                '{': 'LBrace',
-                '}': 'RBrace',
-                '(': 'LParen',
-                ')': 'RParen',
-                '[': 'LBracket',
-                ']': 'RBracket',
-                ';': 'Semicolon',
-                ',': 'Comma',
-                '.': 'Dot',
-            };
-            tokens.push(new Token(mapping[c], null, i));
-            i++;
-            continue;
+        return true;
+    }
+    if (a instanceof GraphTerm) {
+        return alphaEqGraphTriples(a.triples, b.triples);
+    }
+    return false;
+}
+function triplesEqual(a, b) {
+    return termsEqual(a.s, b.s) && termsEqual(a.p, b.p) && termsEqual(a.o, b.o);
+}
+function triplesListEqual(xs, ys) {
+    if (xs.length !== ys.length)
+        return false;
+    for (let i = 0; i < xs.length; i++) {
+        if (!triplesEqual(xs[i], ys[i]))
+            return false;
+    }
+    return true;
+}
+// Alpha-equivalence for quoted formulas, up to *variable* and blank-node renaming.
+// Treats a formula as an unordered set of triples (order-insensitive match).
+function alphaEqVarName(x, y, vmap) {
+    if (vmap.hasOwnProperty(x))
+        return vmap[x] === y;
+    vmap[x] = y;
+    return true;
+}
+function alphaEqTermInGraph(a, b, vmap, bmap) {
+    // Blank nodes: renamable
+    if (a instanceof Blank && b instanceof Blank) {
+        const x = a.label;
+        const y = b.label;
+        if (bmap.hasOwnProperty(x))
+            return bmap[x] === y;
+        bmap[x] = y;
+        return true;
+    }
+    // Variables: renamable (ONLY inside quoted formulas)
+    if (a instanceof Var && b instanceof Var) {
+        return alphaEqVarName(a.name, b.name, vmap);
+    }
+    if (a instanceof Iri && b instanceof Iri)
+        return a.value === b.value;
+    if (a instanceof Literal && b instanceof Literal)
+        return a.value === b.value;
+    if (a instanceof ListTerm && b instanceof ListTerm) {
+        if (a.elems.length !== b.elems.length)
+            return false;
+        for (let i = 0; i < a.elems.length; i++) {
+            if (!alphaEqTermInGraph(a.elems[i], b.elems[i], vmap, bmap))
+                return false;
         }
-        // String literal: short "..." or long """..."""
-        if (c === '"') {
-            const start = i;
-            // Long string literal """ ... """
-            if (peek(1) === '"' && peek(2) === '"') {
-                i += 3; // consume opening """
-                const sChars = [];
-                let closed = false;
-                while (i < n) {
-                    const cc = chars[i];
-                    // Preserve escapes verbatim (same behavior as short strings)
-                    if (cc === '\\') {
-                        i++;
-                        if (i < n) {
-                            const esc = chars[i];
-                            i++;
-                            sChars.push('\\');
-                            sChars.push(esc);
-                        }
-                        else {
-                            sChars.push('\\');
-                        }
-                        continue;
-                    }
-                    // In long strings, a run of >= 3 delimiter quotes terminates the literal.
-                    // Any extra quotes beyond the final 3 are part of the content.
-                    if (cc === '"') {
-                        let run = 0;
-                        while (i + run < n && chars[i + run] === '"')
-                            run++;
-                        if (run >= 3) {
-                            for (let k = 0; k < run - 3; k++)
-                                sChars.push('"');
-                            i += run; // consume content quotes (if any) + closing delimiter
-                            closed = true;
-                            break;
-                        }
-                        for (let k = 0; k < run; k++)
-                            sChars.push('"');
-                        i += run;
-                        continue;
-                    }
-                    sChars.push(cc);
-                    i++;
-                }
-                if (!closed)
-                    throw new N3SyntaxError('Unterminated long string literal """..."""', start);
-                const raw = '"""' + sChars.join('') + '"""';
-                const decoded = decodeN3StringEscapes(stripQuotes(raw));
-                const s = JSON.stringify(decoded); // canonical short quoted form
-                tokens.push(new Token('Literal', s, start));
-                continue;
-            }
-            // Short string literal " ... "
-            i++; // consume opening "
-            const sChars = [];
-            while (i < n) {
-                let cc = chars[i];
-                i++;
-                if (cc === '\\') {
-                    if (i < n) {
-                        const esc = chars[i];
-                        i++;
-                        sChars.push('\\');
-                        sChars.push(esc);
-                    }
-                    continue;
-                }
-                if (cc === '"')
-                    break;
-                sChars.push(cc);
-            }
-            const raw = '"' + sChars.join('') + '"';
-            const decoded = decodeN3StringEscapes(stripQuotes(raw));
-            const s = JSON.stringify(decoded); // canonical short quoted form
-            tokens.push(new Token('Literal', s, start));
-            continue;
+        return true;
+    }
+    if (a instanceof OpenListTerm && b instanceof OpenListTerm) {
+        if (a.prefix.length !== b.prefix.length)
+            return false;
+        for (let i = 0; i < a.prefix.length; i++) {
+            if (!alphaEqTermInGraph(a.prefix[i], b.prefix[i], vmap, bmap))
+                return false;
         }
-        // String literal: short '...' or long '''...'''
-        if (c === "'") {
-            const start = i;
-            // Long string literal ''' ... '''
-            if (peek(1) === "'" && peek(2) === "'") {
-                i += 3; // consume opening '''
-                const sChars = [];
-                let closed = false;
-                while (i < n) {
-                    const cc = chars[i];
-                    // Preserve escapes verbatim (same behavior as short strings)
-                    if (cc === '\\') {
-                        i++;
-                        if (i < n) {
-                            const esc = chars[i];
-                            i++;
-                            sChars.push('\\');
-                            sChars.push(esc);
-                        }
-                        else {
-                            sChars.push('\\');
-                        }
-                        continue;
-                    }
-                    // In long strings, a run of >= 3 delimiter quotes terminates the literal.
-                    // Any extra quotes beyond the final 3 are part of the content.
-                    if (cc === "'") {
-                        let run = 0;
-                        while (i + run < n && chars[i + run] === "'")
-                            run++;
-                        if (run >= 3) {
-                            for (let k = 0; k < run - 3; k++)
-                                sChars.push("'");
-                            i += run; // consume content quotes (if any) + closing delimiter
-                            closed = true;
-                            break;
-                        }
-                        for (let k = 0; k < run; k++)
-                            sChars.push("'");
-                        i += run;
-                        continue;
-                    }
-                    sChars.push(cc);
-                    i++;
-                }
-                if (!closed)
-                    throw new N3SyntaxError("Unterminated long string literal '''...'''", start);
-                const raw = "'''" + sChars.join('') + "'''";
-                const decoded = decodeN3StringEscapes(stripQuotes(raw));
-                const s = JSON.stringify(decoded); // canonical short quoted form
-                tokens.push(new Token('Literal', s, start));
+        // tailVar is a var-name string, so treat it as renamable too
+        return alphaEqVarName(a.tailVar, b.tailVar, vmap);
+    }
+    // Nested formulas: compare with fresh maps (separate scope)
+    if (a instanceof GraphTerm && b instanceof GraphTerm) {
+        return alphaEqGraphTriples(a.triples, b.triples);
+    }
+    return false;
+}
+function alphaEqTripleInGraph(a, b, vmap, bmap) {
+    return (alphaEqTermInGraph(a.s, b.s, vmap, bmap) &&
+        alphaEqTermInGraph(a.p, b.p, vmap, bmap) &&
+        alphaEqTermInGraph(a.o, b.o, vmap, bmap));
+}
+function alphaEqGraphTriples(xs, ys) {
+    if (xs.length !== ys.length)
+        return false;
+    // Fast path: exact same sequence.
+    if (triplesListEqual(xs, ys))
+        return true;
+    // Order-insensitive backtracking match, threading var/blank mappings.
+    const used = new Array(ys.length).fill(false);
+    function step(i, vmap, bmap) {
+        if (i >= xs.length)
+            return true;
+        const x = xs[i];
+        for (let j = 0; j < ys.length; j++) {
+            if (used[j])
                 continue;
-            }
-            // Short string literal ' ... '
-            i++; // consume opening '
-            const sChars = [];
-            while (i < n) {
-                let cc = chars[i];
-                i++;
-                if (cc === '\\') {
-                    if (i < n) {
-                        const esc = chars[i];
-                        i++;
-                        sChars.push('\\');
-                        sChars.push(esc);
-                    }
-                    continue;
-                }
-                if (cc === "'")
-                    break;
-                sChars.push(cc);
-            }
-            const raw = "'" + sChars.join('') + "'";
-            const decoded = decodeN3StringEscapes(stripQuotes(raw));
-            const s = JSON.stringify(decoded); // canonical short quoted form
-            tokens.push(new Token('Literal', s, start));
-            continue;
-        }
-        // Variable ?name
-        if (c === '?') {
-            const start = i;
-            i++;
-            const nameChars = [];
-            let cc;
-            while ((cc = peek()) !== null && isNameChar(cc)) {
-                nameChars.push(cc);
-                i++;
-            }
-            const name = nameChars.join('');
-            tokens.push(new Token('Var', name, start));
-            continue;
-        }
-        // Directives: @prefix, @base (and language tags after string literals)
-        if (c === '@') {
-            const start = i;
-            const prevTok = tokens.length ? tokens[tokens.length - 1] : null;
-            const prevWasQuotedLiteral = prevTok && prevTok.typ === 'Literal' && typeof prevTok.value === 'string' && prevTok.value.startsWith('"');
-            i++; // consume '@'
-            if (prevWasQuotedLiteral) {
-                // N3 grammar production LANGTAG:
-                //   "@" [a-zA-Z]+ ("-" [a-zA-Z0-9]+)*
-                const tagChars = [];
-                let cc = peek();
-                if (cc === null || !/[A-Za-z]/.test(cc)) {
-                    throw new N3SyntaxError("Invalid language tag (expected [A-Za-z] after '@')", start);
-                }
-                while ((cc = peek()) !== null && /[A-Za-z]/.test(cc)) {
-                    tagChars.push(cc);
-                    i++;
-                }
-                while (peek() === '-') {
-                    tagChars.push('-');
-                    i++; // consume '-'
-                    const segChars = [];
-                    while ((cc = peek()) !== null && /[A-Za-z0-9]/.test(cc)) {
-                        segChars.push(cc);
-                        i++;
-                    }
-                    if (!segChars.length) {
-                        throw new N3SyntaxError("Invalid language tag (expected [A-Za-z0-9]+ after '-')", start);
-                    }
-                    tagChars.push(...segChars);
-                }
-                tokens.push(new Token('LangTag', tagChars.join(''), start));
+            const y = ys[j];
+            // Cheap pruning when both predicates are IRIs.
+            if (x.p instanceof Iri && y.p instanceof Iri && x.p.value !== y.p.value)
                 continue;
-            }
-            // Otherwise, treat as a directive (@prefix, @base)
-            const wordChars = [];
-            let cc;
-            while ((cc = peek()) !== null && /[A-Za-z]/.test(cc)) {
-                wordChars.push(cc);
-                i++;
-            }
-            const word = wordChars.join('');
-            if (word === 'prefix')
-                tokens.push(new Token('AtPrefix', null, start));
-            else if (word === 'base')
-                tokens.push(new Token('AtBase', null, start));
-            else
-                throw new N3SyntaxError(`Unknown directive @${word}`, start);
-            continue;
-        }
-        // 6) Numeric literal (integer or float)
-        if (/[0-9]/.test(c) || (c === '-' && peek(1) !== null && /[0-9]/.test(peek(1)))) {
-            const start = i;
-            const numChars = [c];
-            i++;
-            while (i < n) {
-                const cc = chars[i];
-                if (/[0-9]/.test(cc)) {
-                    numChars.push(cc);
-                    i++;
-                    continue;
-                }
-                if (cc === '.') {
-                    if (i + 1 < n && /[0-9]/.test(chars[i + 1])) {
-                        numChars.push('.');
-                        i++;
-                        continue;
-                    }
-                    else {
-                        break;
-                    }
-                }
-                break;
-            }
-            // Optional exponent part: e.g., 1e0, 1.1e-3, 1.1E+0
-            if (i < n && (chars[i] === 'e' || chars[i] === 'E')) {
-                let j = i + 1;
-                if (j < n && (chars[j] === '+' || chars[j] === '-'))
-                    j++;
-                if (j < n && /[0-9]/.test(chars[j])) {
-                    numChars.push(chars[i]); // e/E
-                    i++;
-                    if (i < n && (chars[i] === '+' || chars[i] === '-')) {
-                        numChars.push(chars[i]);
-                        i++;
-                    }
-                    while (i < n && /[0-9]/.test(chars[i])) {
-                        numChars.push(chars[i]);
-                        i++;
-                    }
-                }
-            }
-            tokens.push(new Token('Literal', numChars.join(''), start));
-            continue;
-        }
-        // 7) Identifiers / keywords / QNames
-        const start = i;
-        const wordChars = [];
-        let cc;
-        while ((cc = peek()) !== null && isNameChar(cc)) {
-            wordChars.push(cc);
-            i++;
-        }
-        if (!wordChars.length) {
-            throw new N3SyntaxError(`Unexpected char: ${JSON.stringify(c)}`, i);
-        }
-        const word = wordChars.join('');
-        if (word === 'true' || word === 'false') {
-            tokens.push(new Token('Literal', word, start));
+            const v2 = { ...vmap };
+            const b2 = { ...bmap };
+            if (!alphaEqTripleInGraph(x, y, v2, b2))
+                continue;
+            used[j] = true;
+            if (step(i + 1, v2, b2))
+                return true;
+            used[j] = false;
         }
-        else if ([...word].every((ch) => /[0-9.\-]/.test(ch))) {
-            tokens.push(new Token('Literal', word, start));
+        return false;
+    }
+    return step(0, {}, {});
+}
+function alphaEqTerm(a, b, bmap) {
+    if (a instanceof Blank && b instanceof Blank) {
+        const x = a.label;
+        const y = b.label;
+        if (bmap.hasOwnProperty(x)) {
+            return bmap[x] === y;
         }
         else {
-            tokens.push(new Token('Ident', word, start));
+            bmap[x] = y;
+            return true;
         }
     }
-    tokens.push(new Token('EOF', null, n));
-    return tokens;
-}
-// ===========================================================================
-// PREFIX ENVIRONMENT
-// ===========================================================================
-class PrefixEnv {
-    constructor(map, baseIri) {
-        this.map = map || {}; // prefix -> IRI (including "" for @prefix :)
-        this.baseIri = baseIri || ''; // base IRI for resolving <relative>
-    }
-    static newDefault() {
-        const m = {};
-        m['rdf'] = RDF_NS;
-        m['rdfs'] = RDFS_NS;
-        m['xsd'] = XSD_NS;
-        m['log'] = LOG_NS;
-        m['math'] = MATH_NS;
-        m['string'] = STRING_NS;
-        m['list'] = LIST_NS;
-        m['time'] = TIME_NS;
-        m['genid'] = SKOLEM_NS;
-        m[''] = ''; // empty prefix default namespace
-        return new PrefixEnv(m, ''); // base IRI starts empty
+    if (a instanceof Iri && b instanceof Iri)
+        return a.value === b.value;
+    if (a instanceof Literal && b instanceof Literal)
+        return a.value === b.value;
+    if (a instanceof Var && b instanceof Var)
+        return a.name === b.name;
+    if (a instanceof ListTerm && b instanceof ListTerm) {
+        if (a.elems.length !== b.elems.length)
+            return false;
+        for (let i = 0; i < a.elems.length; i++) {
+            if (!alphaEqTerm(a.elems[i], b.elems[i], bmap))
+                return false;
+        }
+        return true;
     }
-    set(pref, base) {
-        this.map[pref] = base;
+    if (a instanceof OpenListTerm && b instanceof OpenListTerm) {
+        if (a.tailVar !== b.tailVar || a.prefix.length !== b.prefix.length)
+            return false;
+        for (let i = 0; i < a.prefix.length; i++) {
+            if (!alphaEqTerm(a.prefix[i], b.prefix[i], bmap))
+                return false;
+        }
+        return true;
     }
-    setBase(baseIri) {
-        this.baseIri = baseIri || '';
+    if (a instanceof GraphTerm && b instanceof GraphTerm) {
+        // formulas are alpha-equivalent up to var/blank renaming
+        return alphaEqGraphTriples(a.triples, b.triples);
     }
-    expandQName(q) {
-        if (q.includes(':')) {
-            const [p, local] = q.split(':', 2);
-            const base = this.map[p] || '';
-            if (base)
-                return base + local;
-            return q;
+    return false;
+}
+function alphaEqTriple(a, b) {
+    const bmap = {};
+    return alphaEqTerm(a.s, b.s, bmap) && alphaEqTerm(a.p, b.p, bmap) && alphaEqTerm(a.o, b.o, bmap);
+}
+// ===========================================================================
+// Indexes (facts + backward rules)
+// ===========================================================================
+//
+// Facts:
+//   - __byPred: Map<predicateIRI, Triple[]>
+//   - __byPO:   Map<predicateIRI, Map<objectKey, Triple[]>>
+//   - __keySet: Set<"S\tP\tO"> for IRI/Literal-only triples (fast dup check)
+//
+// Backward rules:
+//   - __byHeadPred:   Map<headPredicateIRI, Rule[]>
+//   - __wildHeadPred: Rule[] (non-IRI head predicate)
+function termFastKey(t) {
+    if (t instanceof Iri)
+        return 'I:' + t.value;
+    if (t instanceof Literal)
+        return 'L:' + normalizeLiteralForFastKey(t.value);
+    return null;
+}
+function tripleFastKey(tr) {
+    const ks = termFastKey(tr.s);
+    const kp = termFastKey(tr.p);
+    const ko = termFastKey(tr.o);
+    if (ks === null || kp === null || ko === null)
+        return null;
+    return ks + '\t' + kp + '\t' + ko;
+}
+function ensureFactIndexes(facts) {
+    if (facts.__byPred && facts.__byPS && facts.__byPO && facts.__keySet)
+        return;
+    Object.defineProperty(facts, '__byPred', {
+        value: new Map(),
+        enumerable: false,
+        writable: true,
+    });
+    Object.defineProperty(facts, '__byPS', {
+        value: new Map(),
+        enumerable: false,
+        writable: true,
+    });
+    Object.defineProperty(facts, '__byPO', {
+        value: new Map(),
+        enumerable: false,
+        writable: true,
+    });
+    Object.defineProperty(facts, '__keySet', {
+        value: new Set(),
+        enumerable: false,
+        writable: true,
+    });
+    for (const f of facts)
+        indexFact(facts, f);
+}
+function indexFact(facts, tr) {
+    if (tr.p instanceof Iri) {
+        const pk = tr.p.value;
+        let pb = facts.__byPred.get(pk);
+        if (!pb) {
+            pb = [];
+            facts.__byPred.set(pk, pb);
         }
-        return q;
-    }
-    shrinkIri(iri) {
-        let best = null; // [prefix, local]
-        for (const [p, base] of Object.entries(this.map)) {
-            if (!base)
-                continue;
-            if (iri.startsWith(base)) {
-                const local = iri.slice(base.length);
-                if (!local)
-                    continue;
-                const cand = [p, local];
-                if (best === null || cand[1].length < best[1].length)
-                    best = cand;
+        pb.push(tr);
+        const sk = termFastKey(tr.s);
+        if (sk !== null) {
+            let ps = facts.__byPS.get(pk);
+            if (!ps) {
+                ps = new Map();
+                facts.__byPS.set(pk, ps);
+            }
+            let psb = ps.get(sk);
+            if (!psb) {
+                psb = [];
+                ps.set(sk, psb);
             }
+            psb.push(tr);
         }
-        if (best === null)
-            return null;
-        const [p, local] = best;
-        if (p === '')
-            return `:${local}`;
-        return `${p}:${local}`;
-    }
-    prefixesUsedForOutput(triples) {
-        const used = new Set();
-        for (const t of triples) {
-            const iris = [];
-            iris.push(...collectIrisInTerm(t.s));
-            if (!isRdfTypePred(t.p)) {
-                iris.push(...collectIrisInTerm(t.p));
+        const ok = termFastKey(tr.o);
+        if (ok !== null) {
+            let po = facts.__byPO.get(pk);
+            if (!po) {
+                po = new Map();
+                facts.__byPO.set(pk, po);
             }
-            iris.push(...collectIrisInTerm(t.o));
-            for (const iri of iris) {
-                for (const [p, base] of Object.entries(this.map)) {
-                    if (base && iri.startsWith(base))
-                        used.add(p);
-                }
+            let pob = po.get(ok);
+            if (!pob) {
+                pob = [];
+                po.set(ok, pob);
             }
+            pob.push(tr);
         }
-        const v = [];
-        for (const p of used) {
-            if (this.map.hasOwnProperty(p))
-                v.push([p, this.map[p]]);
-        }
-        v.sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0));
-        return v;
     }
+    const key = tripleFastKey(tr);
+    if (key !== null)
+        facts.__keySet.add(key);
 }
-function collectIrisInTerm(t) {
-    const out = [];
-    if (t instanceof Iri) {
-        out.push(t.value);
-    }
-    else if (t instanceof Literal) {
-        const [_lex, dt] = literalParts(t.value);
-        if (dt)
-            out.push(dt); // so rdf/xsd prefixes are emitted when only used in ^^...
-    }
-    else if (t instanceof ListTerm) {
-        for (const x of t.elems)
-            out.push(...collectIrisInTerm(x));
-    }
-    else if (t instanceof OpenListTerm) {
-        for (const x of t.prefix)
-            out.push(...collectIrisInTerm(x));
-    }
-    else if (t instanceof GraphTerm) {
-        for (const tr of t.triples) {
-            out.push(...collectIrisInTerm(tr.s));
-            out.push(...collectIrisInTerm(tr.p));
-            out.push(...collectIrisInTerm(tr.o));
+function candidateFacts(facts, goal) {
+    ensureFactIndexes(facts);
+    if (goal.p instanceof Iri) {
+        const pk = goal.p.value;
+        const sk = termFastKey(goal.s);
+        const ok = termFastKey(goal.o);
+        /** @type {Triple[] | null} */
+        let byPS = null;
+        if (sk !== null) {
+            const ps = facts.__byPS.get(pk);
+            if (ps)
+                byPS = ps.get(sk) || null;
         }
-    }
-    return out;
-}
-function collectVarsInTerm(t, acc) {
-    if (t instanceof Var) {
-        acc.add(t.name);
-    }
-    else if (t instanceof ListTerm) {
-        for (const x of t.elems)
-            collectVarsInTerm(x, acc);
-    }
-    else if (t instanceof OpenListTerm) {
-        for (const x of t.prefix)
-            collectVarsInTerm(x, acc);
-        acc.add(t.tailVar);
-    }
-    else if (t instanceof GraphTerm) {
-        for (const tr of t.triples) {
-            collectVarsInTerm(tr.s, acc);
-            collectVarsInTerm(tr.p, acc);
-            collectVarsInTerm(tr.o, acc);
+        /** @type {Triple[] | null} */
+        let byPO = null;
+        if (ok !== null) {
+            const po = facts.__byPO.get(pk);
+            if (po)
+                byPO = po.get(ok) || null;
         }
+        if (byPS && byPO)
+            return byPS.length <= byPO.length ? byPS : byPO;
+        if (byPS)
+            return byPS;
+        if (byPO)
+            return byPO;
+        return facts.__byPred.get(pk) || [];
     }
+    return facts;
 }
-function varsInRule(rule) {
-    const acc = new Set();
-    for (const tr of rule.premise) {
-        collectVarsInTerm(tr.s, acc);
-        collectVarsInTerm(tr.p, acc);
-        collectVarsInTerm(tr.o, acc);
+function hasFactIndexed(facts, tr) {
+    ensureFactIndexes(facts);
+    const key = tripleFastKey(tr);
+    if (key !== null)
+        return facts.__keySet.has(key);
+    if (tr.p instanceof Iri) {
+        const pk = tr.p.value;
+        const ok = termFastKey(tr.o);
+        if (ok !== null) {
+            const po = facts.__byPO.get(pk);
+            if (po) {
+                const pob = po.get(ok) || [];
+                // Facts are all in the same graph. Different blank node labels represent
+                // different existentials unless explicitly connected. Do NOT treat
+                // triples as duplicates modulo blank renaming, or you'll incorrectly
+                // drop facts like: _:sk_0 :x 8.0  (because _:b8 :x 8.0 exists).
+                return pob.some((t) => triplesEqual(t, tr));
+            }
+        }
+        const pb = facts.__byPred.get(pk) || [];
+        return pb.some((t) => triplesEqual(t, tr));
     }
-    for (const tr of rule.conclusion) {
-        collectVarsInTerm(tr.s, acc);
-        collectVarsInTerm(tr.p, acc);
-        collectVarsInTerm(tr.o, acc);
+    // Non-IRI predicate: fall back to strict triple equality.
+    return facts.some((t) => triplesEqual(t, tr));
+}
+function pushFactIndexed(facts, tr) {
+    ensureFactIndexes(facts);
+    facts.push(tr);
+    indexFact(facts, tr);
+}
+function ensureBackRuleIndexes(backRules) {
+    if (backRules.__byHeadPred && backRules.__wildHeadPred)
+        return;
+    Object.defineProperty(backRules, '__byHeadPred', {
+        value: new Map(),
+        enumerable: false,
+        writable: true,
+    });
+    Object.defineProperty(backRules, '__wildHeadPred', {
+        value: [],
+        enumerable: false,
+        writable: true,
+    });
+    for (const r of backRules)
+        indexBackRule(backRules, r);
+}
+function indexBackRule(backRules, r) {
+    if (!r || !r.conclusion || r.conclusion.length !== 1)
+        return;
+    const head = r.conclusion[0];
+    if (head && head.p instanceof Iri) {
+        const k = head.p.value;
+        let bucket = backRules.__byHeadPred.get(k);
+        if (!bucket) {
+            bucket = [];
+            backRules.__byHeadPred.set(k, bucket);
+        }
+        bucket.push(r);
+    }
+    else {
+        backRules.__wildHeadPred.push(r);
     }
-    return acc;
 }
-function collectBlankLabelsInTerm(t, acc) {
-    if (t instanceof Blank) {
-        acc.add(t.label);
+// ===========================================================================
+// Special predicate helpers
+// ===========================================================================
+function isRdfTypePred(p) {
+    return p instanceof Iri && p.value === RDF_NS + 'type';
+}
+function isOwlSameAsPred(t) {
+    return t instanceof Iri && t.value === OWL_NS + 'sameAs';
+}
+function isLogImplies(p) {
+    return p instanceof Iri && p.value === LOG_NS + 'implies';
+}
+function isLogImpliedBy(p) {
+    return p instanceof Iri && p.value === LOG_NS + 'impliedBy';
+}
+// ===========================================================================
+// Constraint / "test" builtins
+// ===========================================================================
+function isConstraintBuiltin(tr) {
+    if (!(tr.p instanceof Iri))
+        return false;
+    const v = tr.p.value;
+    // math: numeric comparisons (no new bindings, just tests)
+    if (v === MATH_NS + 'equalTo' ||
+        v === MATH_NS + 'greaterThan' ||
+        v === MATH_NS + 'lessThan' ||
+        v === MATH_NS + 'notEqualTo' ||
+        v === MATH_NS + 'notGreaterThan' ||
+        v === MATH_NS + 'notLessThan') {
+        return true;
     }
-    else if (t instanceof ListTerm) {
-        for (const x of t.elems)
-            collectBlankLabelsInTerm(x, acc);
+    // list: membership test with no bindings
+    if (v === LIST_NS + 'notMember') {
+        return true;
     }
-    else if (t instanceof OpenListTerm) {
-        for (const x of t.prefix)
-            collectBlankLabelsInTerm(x, acc);
+    // log: tests that are purely constraints (no new bindings)
+    if (v === LOG_NS + 'forAllIn' ||
+        v === LOG_NS + 'notEqualTo' ||
+        v === LOG_NS + 'notIncludes' ||
+        v === LOG_NS + 'outputString') {
+        return true;
     }
-    else if (t instanceof GraphTerm) {
-        for (const tr of t.triples) {
-            collectBlankLabelsInTerm(tr.s, acc);
-            collectBlankLabelsInTerm(tr.p, acc);
-            collectBlankLabelsInTerm(tr.o, acc);
-        }
+    // string: relational / membership style tests (no bindings)
+    if (v === STRING_NS + 'contains' ||
+        v === STRING_NS + 'containsIgnoringCase' ||
+        v === STRING_NS + 'endsWith' ||
+        v === STRING_NS + 'equalIgnoringCase' ||
+        v === STRING_NS + 'greaterThan' ||
+        v === STRING_NS + 'lessThan' ||
+        v === STRING_NS + 'matches' ||
+        v === STRING_NS + 'notEqualIgnoringCase' ||
+        v === STRING_NS + 'notGreaterThan' ||
+        v === STRING_NS + 'notLessThan' ||
+        v === STRING_NS + 'notMatches' ||
+        v === STRING_NS + 'startsWith') {
+        return true;
     }
+    return false;
 }
-function collectBlankLabelsInTriples(triples) {
-    const acc = new Set();
-    for (const tr of triples) {
-        collectBlankLabelsInTerm(tr.s, acc);
-        collectBlankLabelsInTerm(tr.p, acc);
-        collectBlankLabelsInTerm(tr.o, acc);
+// Move constraint builtins to the end of the rule premise.
+// This is a simple "delaying" strategy similar in spirit to Prolog's when/2:
+// - normal goals first (can bind variables),
+// - pure test / constraint builtins last (checked once bindings are in place).
+function reorderPremiseForConstraints(premise) {
+    if (!premise || premise.length === 0)
+        return premise;
+    const normal = [];
+    const delayed = [];
+    for (const tr of premise) {
+        if (isConstraintBuiltin(tr))
+            delayed.push(tr);
+        else
+            normal.push(tr);
     }
-    return acc;
+    return normal.concat(delayed);
 }
+// @ts-nocheck
+/* eslint-disable */
 // ===========================================================================
-// PARSER
+// N3 lexer + parser
 // ===========================================================================
-class Parser {
-    constructor(tokens) {
-        this.toks = tokens;
-        this.pos = 0;
-        this.prefixes = PrefixEnv.newDefault();
-        this.blankCounter = 0;
-        this.pendingTriples = [];
-    }
-    peek() {
-        return this.toks[this.pos];
+// ===========================================================================
+// LEXER
+// ===========================================================================
+class Token {
+    constructor(typ, value = null, offset = null) {
+        this.typ = typ;
+        this.value = value;
+        // Codepoint offset in the original source (Array.from(text) index).
+        this.offset = offset;
     }
-    next() {
-        const tok = this.toks[this.pos];
-        this.pos += 1;
-        return tok;
+    toString() {
+        const loc = typeof this.offset === 'number' ? `@${this.offset}` : '';
+        if (this.value == null)
+            return `Token(${this.typ}${loc})`;
+        return `Token(${this.typ}${loc}, ${JSON.stringify(this.value)})`;
     }
-    fail(message, tok = this.peek()) {
-        const off = tok && typeof tok.offset === 'number' ? tok.offset : null;
-        throw new N3SyntaxError(message, off);
+}
+class N3SyntaxError extends SyntaxError {
+    constructor(message, offset = null) {
+        super(message);
+        this.name = 'N3SyntaxError';
+        this.offset = offset;
     }
-    expectDot() {
-        const tok = this.next();
-        if (tok.typ !== 'Dot') {
-            this.fail(`Expected '.', got ${tok.toString()}`, tok);
+}
+function isWs(c) {
+    return /\s/.test(c);
+}
+function isNameChar(c) {
+    return /[0-9A-Za-z_\-:]/.test(c);
+}
+function decodeN3StringEscapes(s) {
+    let out = '';
+    for (let i = 0; i < s.length; i++) {
+        const c = s[i];
+        if (c !== '\\') {
+            out += c;
+            continue;
         }
-    }
-    parseDocument() {
-        const triples = [];
-        const forwardRules = [];
-        const backwardRules = [];
-        while (this.peek().typ !== 'EOF') {
-            if (this.peek().typ === 'AtPrefix') {
-                this.next();
-                this.parsePrefixDirective();
-            }
-            else if (this.peek().typ === 'AtBase') {
-                this.next();
-                this.parseBaseDirective();
-            }
-            else if (
-            // SPARQL-style/Turtle-style directives (case-insensitive, no trailing '.')
-            this.peek().typ === 'Ident' &&
-                typeof this.peek().value === 'string' &&
-                this.peek().value.toLowerCase() === 'prefix' &&
-                this.toks[this.pos + 1] &&
-                this.toks[this.pos + 1].typ === 'Ident' &&
-                typeof this.toks[this.pos + 1].value === 'string' &&
-                // Require PNAME_NS form (e.g., "ex:" or ":") to avoid clashing with a normal triple starting with IRI "prefix".
-                this.toks[this.pos + 1].value.endsWith(':') &&
-                this.toks[this.pos + 2] &&
-                (this.toks[this.pos + 2].typ === 'IriRef' || this.toks[this.pos + 2].typ === 'Ident')) {
-                this.next(); // consume PREFIX keyword
-                this.parseSparqlPrefixDirective();
-            }
-            else if (this.peek().typ === 'Ident' &&
-                typeof this.peek().value === 'string' &&
-                this.peek().value.toLowerCase() === 'base' &&
-                this.toks[this.pos + 1] &&
-                // SPARQL BASE requires an IRIREF.
-                this.toks[this.pos + 1].typ === 'IriRef') {
-                this.next(); // consume BASE keyword
-                this.parseSparqlBaseDirective();
-            }
-            else {
-                const first = this.parseTerm();
-                if (this.peek().typ === 'OpImplies') {
-                    this.next();
-                    const second = this.parseTerm();
-                    this.expectDot();
-                    forwardRules.push(this.makeRule(first, second, true));
+        if (i + 1 >= s.length) {
+            out += '\\';
+            continue;
+        }
+        const e = s[++i];
+        switch (e) {
+            case 't':
+                out += '\t';
+                break;
+            case 'n':
+                out += '\n';
+                break;
+            case 'r':
+                out += '\r';
+                break;
+            case 'b':
+                out += '\b';
+                break;
+            case 'f':
+                out += '\f';
+                break;
+            case '"':
+                out += '"';
+                break;
+            case "'":
+                out += "'";
+                break;
+            case '\\':
+                out += '\\';
+                break;
+            case 'u': {
+                const hex = s.slice(i + 1, i + 5);
+                if (/^[0-9A-Fa-f]{4}$/.test(hex)) {
+                    out += String.fromCharCode(parseInt(hex, 16));
+                    i += 4;
                 }
-                else if (this.peek().typ === 'OpImpliedBy') {
-                    this.next();
-                    const second = this.parseTerm();
-                    this.expectDot();
-                    backwardRules.push(this.makeRule(first, second, false));
+                else {
+                    out += '\\u';
+                }
+                break;
+            }
+            case 'U': {
+                const hex = s.slice(i + 1, i + 9);
+                if (/^[0-9A-Fa-f]{8}$/.test(hex)) {
+                    const cp = parseInt(hex, 16);
+                    if (cp >= 0 && cp <= 0x10ffff)
+                        out += String.fromCodePoint(cp);
+                    else
+                        out += '\\U' + hex;
+                    i += 8;
                 }
                 else {
-                    let more;
-                    if (this.peek().typ === 'Dot') {
-                        // N3 grammar allows: triples ::= subject predicateObjectList?
-                        // So a bare subject followed by '.' is syntactically valid.
-                        // If the subject was a path / property-list that generated helper triples,
-                        // we emit those; otherwise this statement contributes no triples.
-                        more = [];
-                        if (this.pendingTriples.length > 0) {
-                            more = this.pendingTriples;
-                            this.pendingTriples = [];
-                        }
-                        this.next(); // consume '.'
-                    }
-                    else {
-                        more = this.parsePredicateObjectList(first);
-                        this.expectDot();
-                    }
-                    // normalize explicit log:implies / log:impliedBy at top-level
-                    for (const tr of more) {
-                        if (isLogImplies(tr.p) && tr.s instanceof GraphTerm && tr.o instanceof GraphTerm) {
-                            forwardRules.push(this.makeRule(tr.s, tr.o, true));
-                        }
-                        else if (isLogImpliedBy(tr.p) && tr.s instanceof GraphTerm && tr.o instanceof GraphTerm) {
-                            backwardRules.push(this.makeRule(tr.s, tr.o, false));
-                        }
-                        else {
-                            triples.push(tr);
-                        }
-                    }
+                    out += '\\U';
                 }
+                break;
             }
+            default:
+                // preserve unknown escapes
+                out += '\\' + e;
         }
-        return [this.prefixes, triples, forwardRules, backwardRules];
     }
-    parsePrefixDirective() {
-        const tok = this.next();
-        if (tok.typ !== 'Ident') {
-            this.fail(`Expected prefix name, got ${tok.toString()}`, tok);
-        }
-        const pref = tok.value || '';
-        const prefName = pref.endsWith(':') ? pref.slice(0, -1) : pref;
-        if (this.peek().typ === 'Dot') {
-            this.next();
-            if (!this.prefixes.map.hasOwnProperty(prefName)) {
-                this.prefixes.set(prefName, '');
-            }
-            return;
-        }
-        const tok2 = this.next();
-        let iri;
-        if (tok2.typ === 'IriRef') {
-            iri = resolveIriRef(tok2.value || '', this.prefixes.baseIri || '');
-        }
-        else if (tok2.typ === 'Ident') {
-            iri = this.prefixes.expandQName(tok2.value || '');
-        }
-        else {
-            this.fail(`Expected IRI after @prefix, got ${tok2.toString()}`, tok2);
-        }
-        this.expectDot();
-        this.prefixes.set(prefName, iri);
+    return out;
+}
+function lex(inputText) {
+    const chars = Array.from(inputText);
+    const n = chars.length;
+    let i = 0;
+    const tokens = [];
+    function peek(offset = 0) {
+        const j = i + offset;
+        return j >= 0 && j < n ? chars[j] : null;
     }
-    parseBaseDirective() {
-        const tok = this.next();
-        let iri;
-        if (tok.typ === 'IriRef') {
-            iri = resolveIriRef(tok.value || '', this.prefixes.baseIri || '');
-        }
-        else if (tok.typ === 'Ident') {
-            iri = tok.value || '';
+    while (i < n) {
+        let c = peek();
+        if (c === null)
+            break;
+        // 1) Whitespace
+        if (isWs(c)) {
+            i++;
+            continue;
         }
-        else {
-            this.fail(`Expected IRI after @base, got ${tok.toString()}`, tok);
+        // 2) Comments starting with '#'
+        if (c === '#') {
+            while (i < n && chars[i] !== '\n' && chars[i] !== '\r')
+                i++;
+            continue;
         }
-        this.expectDot();
-        this.prefixes.setBase(iri);
-    }
-    parseSparqlPrefixDirective() {
-        // SPARQL/Turtle-style PREFIX directive: PREFIX pfx: <iri>  (no trailing '.')
-        const tok = this.next();
-        if (tok.typ !== 'Ident') {
-            this.fail(`Expected prefix name after PREFIX, got ${tok.toString()}`, tok);
+        // 3) Two-character operators: => and <=
+        if (c === '=') {
+            if (peek(1) === '>') {
+                tokens.push(new Token('OpImplies', null, i));
+                i += 2;
+                continue;
+            }
+            else {
+                // N3 syntactic sugar: '=' means owl:sameAs
+                tokens.push(new Token('Equals', null, i));
+                i += 1;
+                continue;
+            }
         }
-        const pref = tok.value || '';
-        const prefName = pref.endsWith(':') ? pref.slice(0, -1) : pref;
-        const tok2 = this.next();
-        let iri;
-        if (tok2.typ === 'IriRef') {
-            iri = resolveIriRef(tok2.value || '', this.prefixes.baseIri || '');
+        if (c === '<') {
+            if (peek(1) === '=') {
+                tokens.push(new Token('OpImpliedBy', null, i));
+                i += 2;
+                continue;
+            }
+            // N3 predicate inversion: "<-" (swap subject/object for this predicate)
+            if (peek(1) === '-') {
+                tokens.push(new Token('OpPredInvert', null, i));
+                i += 2;
+                continue;
+            }
+            // Otherwise IRIREF <...>
+            const start = i;
+            i++; // skip '<'
+            const iriChars = [];
+            while (i < n && chars[i] !== '>') {
+                iriChars.push(chars[i]);
+                i++;
+            }
+            if (i >= n || chars[i] !== '>') {
+                throw new N3SyntaxError('Unterminated IRI <...>', start);
+            }
+            i++; // skip '>'
+            const iri = iriChars.join('');
+            tokens.push(new Token('IriRef', iri, start));
+            continue;
         }
-        else if (tok2.typ === 'Ident') {
-            iri = this.prefixes.expandQName(tok2.value || '');
+        // 4) Path + datatype operators: !, ^, ^^
+        if (c === '!') {
+            tokens.push(new Token('OpPathFwd', null, i));
+            i += 1;
+            continue;
         }
-        else {
-            this.fail(`Expected IRI after PREFIX, got ${tok2.toString()}`, tok2);
+        if (c === '^') {
+            if (peek(1) === '^') {
+                tokens.push(new Token('HatHat', null, i));
+                i += 2;
+                continue;
+            }
+            tokens.push(new Token('OpPathRev', null, i));
+            i += 1;
+            continue;
         }
-        // N3/Turtle: PREFIX directives do not have a trailing '.', but accept it permissively.
-        if (this.peek().typ === 'Dot')
-            this.next();
-        this.prefixes.set(prefName, iri);
-    }
-    parseSparqlBaseDirective() {
-        // SPARQL/Turtle-style BASE directive: BASE <iri>  (no trailing '.')
-        const tok = this.next();
-        let iri;
-        if (tok.typ === 'IriRef') {
-            iri = resolveIriRef(tok.value || '', this.prefixes.baseIri || '');
+        // 5) Single-character punctuation
+        if ('{}()[];,.'.includes(c)) {
+            const mapping = {
+                '{': 'LBrace',
+                '}': 'RBrace',
+                '(': 'LParen',
+                ')': 'RParen',
+                '[': 'LBracket',
+                ']': 'RBracket',
+                ';': 'Semicolon',
+                ',': 'Comma',
+                '.': 'Dot',
+            };
+            tokens.push(new Token(mapping[c], null, i));
+            i++;
+            continue;
         }
-        else if (tok.typ === 'Ident') {
-            iri = tok.value || '';
-        }
-        else {
-            this.fail(`Expected IRI after BASE, got ${tok.toString()}`, tok);
-        }
-        // N3/Turtle: BASE directives do not have a trailing '.', but accept it permissively.
-        if (this.peek().typ === 'Dot')
-            this.next();
-        this.prefixes.setBase(iri);
-    }
-    parseTerm() {
-        let t = this.parsePathItem();
-        while (this.peek().typ === 'OpPathFwd' || this.peek().typ === 'OpPathRev') {
-            const dir = this.next().typ; // OpPathFwd | OpPathRev
-            const pred = this.parsePathItem();
-            this.blankCounter += 1;
-            const bn = new Blank(`_:b${this.blankCounter}`);
-            this.pendingTriples.push(dir === 'OpPathFwd' ? new Triple(t, pred, bn) : new Triple(bn, pred, t));
-            t = bn;
-        }
-        return t;
-    }
-    parsePathItem() {
-        const tok = this.next();
-        const typ = tok.typ;
-        const val = tok.value;
-        if (typ === 'Equals') {
-            return internIri(OWL_NS + 'sameAs');
-        }
-        if (typ === 'IriRef') {
-            const base = this.prefixes.baseIri || '';
-            return internIri(resolveIriRef(val || '', base));
-        }
-        if (typ === 'Ident') {
-            const name = val || '';
-            if (name === 'a') {
-                return internIri(RDF_NS + 'type');
-            }
-            else if (name.startsWith('_:')) {
-                return new Blank(name);
-            }
-            else if (name.includes(':')) {
-                return internIri(this.prefixes.expandQName(name));
+        // String literal: short "..." or long """..."""
+        if (c === '"') {
+            const start = i;
+            // Long string literal """ ... """
+            if (peek(1) === '"' && peek(2) === '"') {
+                i += 3; // consume opening """
+                const sChars = [];
+                let closed = false;
+                while (i < n) {
+                    const cc = chars[i];
+                    // Preserve escapes verbatim (same behavior as short strings)
+                    if (cc === '\\') {
+                        i++;
+                        if (i < n) {
+                            const esc = chars[i];
+                            i++;
+                            sChars.push('\\');
+                            sChars.push(esc);
+                        }
+                        else {
+                            sChars.push('\\');
+                        }
+                        continue;
+                    }
+                    // In long strings, a run of >= 3 delimiter quotes terminates the literal.
+                    // Any extra quotes beyond the final 3 are part of the content.
+                    if (cc === '"') {
+                        let run = 0;
+                        while (i + run < n && chars[i + run] === '"')
+                            run++;
+                        if (run >= 3) {
+                            for (let k = 0; k < run - 3; k++)
+                                sChars.push('"');
+                            i += run; // consume content quotes (if any) + closing delimiter
+                            closed = true;
+                            break;
+                        }
+                        for (let k = 0; k < run; k++)
+                            sChars.push('"');
+                        i += run;
+                        continue;
+                    }
+                    sChars.push(cc);
+                    i++;
+                }
+                if (!closed)
+                    throw new N3SyntaxError('Unterminated long string literal """..."""', start);
+                const raw = '"""' + sChars.join('') + '"""';
+                const decoded = decodeN3StringEscapes(stripQuotes(raw));
+                const s = JSON.stringify(decoded); // canonical short quoted form
+                tokens.push(new Token('Literal', s, start));
+                continue;
             }
-            else {
-                return internIri(name);
+            // Short string literal " ... "
+            i++; // consume opening "
+            const sChars = [];
+            while (i < n) {
+                let cc = chars[i];
+                i++;
+                if (cc === '\\') {
+                    if (i < n) {
+                        const esc = chars[i];
+                        i++;
+                        sChars.push('\\');
+                        sChars.push(esc);
+                    }
+                    continue;
+                }
+                if (cc === '"')
+                    break;
+                sChars.push(cc);
             }
+            const raw = '"' + sChars.join('') + '"';
+            const decoded = decodeN3StringEscapes(stripQuotes(raw));
+            const s = JSON.stringify(decoded); // canonical short quoted form
+            tokens.push(new Token('Literal', s, start));
+            continue;
         }
-        if (typ === 'Literal') {
-            let s = val || '';
-            // Optional language tag: "..."@en, per N3 LANGTAG production.
-            if (this.peek().typ === 'LangTag') {
-                // Only quoted string literals can carry a language tag.
-                if (!(s.startsWith('"') && s.endsWith('"'))) {
-                    this.fail('Language tag is only allowed on quoted string literals', this.peek());
-                }
-                const langTok = this.next();
-                const lang = langTok.value || '';
-                s = `${s}@${lang}`;
-                // N3/Turtle: language tags and datatypes are mutually exclusive.
-                if (this.peek().typ === 'HatHat') {
-                    this.fail('A literal cannot have both a language tag (@...) and a datatype (^^...)', this.peek());
+        // String literal: short '...' or long '''...'''
+        if (c === "'") {
+            const start = i;
+            // Long string literal ''' ... '''
+            if (peek(1) === "'" && peek(2) === "'") {
+                i += 3; // consume opening '''
+                const sChars = [];
+                let closed = false;
+                while (i < n) {
+                    const cc = chars[i];
+                    // Preserve escapes verbatim (same behavior as short strings)
+                    if (cc === '\\') {
+                        i++;
+                        if (i < n) {
+                            const esc = chars[i];
+                            i++;
+                            sChars.push('\\');
+                            sChars.push(esc);
+                        }
+                        else {
+                            sChars.push('\\');
+                        }
+                        continue;
+                    }
+                    // In long strings, a run of >= 3 delimiter quotes terminates the literal.
+                    // Any extra quotes beyond the final 3 are part of the content.
+                    if (cc === "'") {
+                        let run = 0;
+                        while (i + run < n && chars[i + run] === "'")
+                            run++;
+                        if (run >= 3) {
+                            for (let k = 0; k < run - 3; k++)
+                                sChars.push("'");
+                            i += run; // consume content quotes (if any) + closing delimiter
+                            closed = true;
+                            break;
+                        }
+                        for (let k = 0; k < run; k++)
+                            sChars.push("'");
+                        i += run;
+                        continue;
+                    }
+                    sChars.push(cc);
+                    i++;
                 }
+                if (!closed)
+                    throw new N3SyntaxError("Unterminated long string literal '''...'''", start);
+                const raw = "'''" + sChars.join('') + "'''";
+                const decoded = decodeN3StringEscapes(stripQuotes(raw));
+                const s = JSON.stringify(decoded); // canonical short quoted form
+                tokens.push(new Token('Literal', s, start));
+                continue;
             }
-            if (this.peek().typ === 'HatHat') {
-                this.next();
-                const dtTok = this.next();
-                let dtIri;
-                if (dtTok.typ === 'IriRef') {
-                    dtIri = dtTok.value || '';
-                }
-                else if (dtTok.typ === 'Ident') {
-                    const qn = dtTok.value || '';
-                    if (qn.includes(':'))
-                        dtIri = this.prefixes.expandQName(qn);
-                    else
-                        dtIri = qn;
-                }
-                else {
-                    this.fail(`Expected datatype after ^^, got ${dtTok.toString()}`, dtTok);
+            // Short string literal ' ... '
+            i++; // consume opening '
+            const sChars = [];
+            while (i < n) {
+                let cc = chars[i];
+                i++;
+                if (cc === '\\') {
+                    if (i < n) {
+                        const esc = chars[i];
+                        i++;
+                        sChars.push('\\');
+                        sChars.push(esc);
+                    }
+                    continue;
                 }
-                s = `${s}^^<${dtIri}>`;
+                if (cc === "'")
+                    break;
+                sChars.push(cc);
             }
-            return internLiteral(s);
+            const raw = "'" + sChars.join('') + "'";
+            const decoded = decodeN3StringEscapes(stripQuotes(raw));
+            const s = JSON.stringify(decoded); // canonical short quoted form
+            tokens.push(new Token('Literal', s, start));
+            continue;
         }
-        if (typ === 'Var')
-            return new Var(val || '');
-        if (typ === 'LParen')
-            return this.parseList();
-        if (typ === 'LBracket')
-            return this.parseBlank();
-        if (typ === 'LBrace')
-            return this.parseGraph();
-        this.fail(`Unexpected term token: ${tok.toString()}`, tok);
-    }
-    parseList() {
-        const elems = [];
-        while (this.peek().typ !== 'RParen') {
-            elems.push(this.parseTerm());
+        // Variable ?name
+        if (c === '?') {
+            const start = i;
+            i++;
+            const nameChars = [];
+            let cc;
+            while ((cc = peek()) !== null && isNameChar(cc)) {
+                nameChars.push(cc);
+                i++;
+            }
+            const name = nameChars.join('');
+            tokens.push(new Token('Var', name, start));
+            continue;
         }
-        this.next(); // consume ')'
-        return new ListTerm(elems);
-    }
-    parseBlank() {
-        // [] or [ ... ] property list
-        if (this.peek().typ === 'RBracket') {
-            this.next();
-            this.blankCounter += 1;
-            return new Blank(`_:b${this.blankCounter}`);
-        }
-        // IRI property list: [ id <IRI> predicateObjectList? ]
-        // Lets you embed descriptions of an IRI directly in object position.
-        if (this.peek().typ === 'Ident' && (this.peek().value || '') === 'id') {
-            const iriTok = this.next(); // consume 'id'
-            const iriTerm = this.parseTerm();
-            // N3 note: 'id' form is not meant to be used with blank node identifiers.
-            if (iriTerm instanceof Blank && iriTerm.label.startsWith('_:')) {
-                this.fail("Cannot use 'id' keyword with a blank node identifier inside [...]", iriTok);
-            }
-            // Optional ';' right after the id IRI (tolerated).
-            if (this.peek().typ === 'Semicolon')
-                this.next();
-            // Empty IRI property list: [ id :iri ]
-            if (this.peek().typ === 'RBracket') {
-                this.next();
-                return iriTerm;
-            }
-            const subj = iriTerm;
-            while (true) {
-                let pred;
-                let invert = false;
-                if (this.peek().typ === 'Ident' && (this.peek().value || '') === 'a') {
-                    this.next();
-                    pred = internIri(RDF_NS + 'type');
-                }
-                else if (this.peek().typ === 'OpPredInvert') {
-                    this.next(); // "<-"
-                    pred = this.parseTerm();
-                    invert = true;
+        // Directives: @prefix, @base (and language tags after string literals)
+        if (c === '@') {
+            const start = i;
+            const prevTok = tokens.length ? tokens[tokens.length - 1] : null;
+            const prevWasQuotedLiteral = prevTok && prevTok.typ === 'Literal' && typeof prevTok.value === 'string' && prevTok.value.startsWith('"');
+            i++; // consume '@'
+            if (prevWasQuotedLiteral) {
+                // N3 grammar production LANGTAG:
+                //   "@" [a-zA-Z]+ ("-" [a-zA-Z0-9]+)*
+                const tagChars = [];
+                let cc = peek();
+                if (cc === null || !/[A-Za-z]/.test(cc)) {
+                    throw new N3SyntaxError("Invalid language tag (expected [A-Za-z] after '@')", start);
                 }
-                else {
-                    pred = this.parseTerm();
+                while ((cc = peek()) !== null && /[A-Za-z]/.test(cc)) {
+                    tagChars.push(cc);
+                    i++;
                 }
-                const objs = [this.parseTerm()];
-                while (this.peek().typ === 'Comma') {
-                    this.next();
-                    objs.push(this.parseTerm());
+                while (peek() === '-') {
+                    tagChars.push('-');
+                    i++; // consume '-'
+                    const segChars = [];
+                    while ((cc = peek()) !== null && /[A-Za-z0-9]/.test(cc)) {
+                        segChars.push(cc);
+                        i++;
+                    }
+                    if (!segChars.length) {
+                        throw new N3SyntaxError("Invalid language tag (expected [A-Za-z0-9]+ after '-')", start);
+                    }
+                    tagChars.push(...segChars);
                 }
-                for (const o of objs) {
-                    this.pendingTriples.push(invert ? new Triple(o, pred, subj) : new Triple(subj, pred, o));
+                tokens.push(new Token('LangTag', tagChars.join(''), start));
+                continue;
+            }
+            // Otherwise, treat as a directive (@prefix, @base)
+            const wordChars = [];
+            let cc;
+            while ((cc = peek()) !== null && /[A-Za-z]/.test(cc)) {
+                wordChars.push(cc);
+                i++;
+            }
+            const word = wordChars.join('');
+            if (word === 'prefix')
+                tokens.push(new Token('AtPrefix', null, start));
+            else if (word === 'base')
+                tokens.push(new Token('AtBase', null, start));
+            else
+                throw new N3SyntaxError(`Unknown directive @${word}`, start);
+            continue;
+        }
+        // 6) Numeric literal (integer or float)
+        if (/[0-9]/.test(c) || (c === '-' && peek(1) !== null && /[0-9]/.test(peek(1)))) {
+            const start = i;
+            const numChars = [c];
+            i++;
+            while (i < n) {
+                const cc = chars[i];
+                if (/[0-9]/.test(cc)) {
+                    numChars.push(cc);
+                    i++;
+                    continue;
                 }
-                if (this.peek().typ === 'Semicolon') {
-                    this.next();
-                    if (this.peek().typ === 'RBracket')
+                if (cc === '.') {
+                    if (i + 1 < n && /[0-9]/.test(chars[i + 1])) {
+                        numChars.push('.');
+                        i++;
+                        continue;
+                    }
+                    else {
                         break;
-                    continue;
+                    }
                 }
                 break;
             }
-            if (this.peek().typ !== 'RBracket') {
-                this.fail(`Expected ']' at end of IRI property list, got ${this.peek().toString()}`);
+            // Optional exponent part: e.g., 1e0, 1.1e-3, 1.1E+0
+            if (i < n && (chars[i] === 'e' || chars[i] === 'E')) {
+                let j = i + 1;
+                if (j < n && (chars[j] === '+' || chars[j] === '-'))
+                    j++;
+                if (j < n && /[0-9]/.test(chars[j])) {
+                    numChars.push(chars[i]); // e/E
+                    i++;
+                    if (i < n && (chars[i] === '+' || chars[i] === '-')) {
+                        numChars.push(chars[i]);
+                        i++;
+                    }
+                    while (i < n && /[0-9]/.test(chars[i])) {
+                        numChars.push(chars[i]);
+                        i++;
+                    }
+                }
             }
-            this.next();
-            return iriTerm;
+            tokens.push(new Token('Literal', numChars.join(''), start));
+            continue;
         }
-        // [ predicateObjectList ]
-        this.blankCounter += 1;
-        const id = `_:b${this.blankCounter}`;
-        const subj = new Blank(id);
-        while (true) {
-            // Verb (can also be 'a')
-            let pred;
-            let invert = false;
-            if (this.peek().typ === 'Ident' && (this.peek().value || '') === 'a') {
-                this.next();
-                pred = internIri(RDF_NS + 'type');
-            }
-            else if (this.peek().typ === 'OpPredInvert') {
-                this.next(); // consume "<-"
-                pred = this.parseTerm();
-                invert = true;
-            }
-            else {
-                pred = this.parseTerm();
-            }
-            // Object list: o1, o2, ...
-            const objs = [this.parseTerm()];
-            while (this.peek().typ === 'Comma') {
-                this.next();
-                objs.push(this.parseTerm());
-            }
-            for (const o of objs) {
-                this.pendingTriples.push(invert ? new Triple(o, pred, subj) : new Triple(subj, pred, o));
-            }
-            if (this.peek().typ === 'Semicolon') {
-                this.next();
-                if (this.peek().typ === 'RBracket')
-                    break;
-                continue;
-            }
-            break;
+        // 7) Identifiers / keywords / QNames
+        const start = i;
+        const wordChars = [];
+        let cc;
+        while ((cc = peek()) !== null && isNameChar(cc)) {
+            wordChars.push(cc);
+            i++;
         }
-        if (this.peek().typ === 'RBracket') {
-            this.next();
+        if (!wordChars.length) {
+            throw new N3SyntaxError(`Unexpected char: ${JSON.stringify(c)}`, i);
         }
-        else {
-            this.fail(`Expected ']' at end of blank node property list, got ${this.peek().toString()}`);
+        const word = wordChars.join('');
+        if (word === 'true' || word === 'false') {
+            tokens.push(new Token('Literal', word, start));
         }
-        return new Blank(id);
-    }
-    parseGraph() {
-        const triples = [];
-        while (this.peek().typ !== 'RBrace') {
-            const left = this.parseTerm();
-            if (this.peek().typ === 'OpImplies') {
-                this.next();
-                const right = this.parseTerm();
-                const pred = internIri(LOG_NS + 'implies');
-                triples.push(new Triple(left, pred, right));
-                if (this.peek().typ === 'Dot')
-                    this.next();
-                else if (this.peek().typ === 'RBrace') {
-                    // ok
-                }
-                else {
-                    this.fail(`Expected '.' or '}', got ${this.peek().toString()}`);
-                }
-            }
-            else if (this.peek().typ === 'OpImpliedBy') {
-                this.next();
-                const right = this.parseTerm();
-                const pred = internIri(LOG_NS + 'impliedBy');
-                triples.push(new Triple(left, pred, right));
-                if (this.peek().typ === 'Dot')
-                    this.next();
-                else if (this.peek().typ === 'RBrace') {
-                    // ok
-                }
-                else {
-                    this.fail(`Expected '.' or '}', got ${this.peek().toString()}`);
-                }
-            }
-            else {
-                // N3 grammar allows: triples ::= subject predicateObjectList?
-                // So a bare subject (optionally producing helper triples) is allowed inside formulas as well.
-                if (this.peek().typ === 'Dot' || this.peek().typ === 'RBrace') {
-                    if (this.pendingTriples.length > 0) {
-                        triples.push(...this.pendingTriples);
-                        this.pendingTriples = [];
-                    }
-                    if (this.peek().typ === 'Dot')
-                        this.next();
-                    continue;
-                }
-                triples.push(...this.parsePredicateObjectList(left));
-                if (this.peek().typ === 'Dot')
-                    this.next();
-                else if (this.peek().typ === 'RBrace') {
-                    // ok
-                }
-                else {
-                    this.fail(`Expected '.' or '}', got ${this.peek().toString()}`);
-                }
-            }
+        else if ([...word].every((ch) => /[0-9.\-]/.test(ch))) {
+            tokens.push(new Token('Literal', word, start));
+        }
+        else {
+            tokens.push(new Token('Ident', word, start));
         }
-        this.next(); // consume '}'
-        return new GraphTerm(triples);
     }
-    parsePredicateObjectList(subject) {
-        const out = [];
-        // If the SUBJECT was a path, emit its helper triples first
-        if (this.pendingTriples.length > 0) {
-            out.push(...this.pendingTriples);
-            this.pendingTriples = [];
-        }
-        while (true) {
-            let verb;
-            let invert = false;
-            if (this.peek().typ === 'Ident' && (this.peek().value || '') === 'a') {
-                this.next();
-                verb = internIri(RDF_NS + 'type');
-            }
-            else if (this.peek().typ === 'Ident' && (this.peek().value || '') === 'has') {
-                // N3 syntactic sugar: "S has P O." means "S P O."
-                this.next(); // consume "has"
-                verb = this.parseTerm();
-            }
-            else if (this.peek().typ === 'Ident' && (this.peek().value || '') === 'is') {
-                // N3 syntactic sugar: "S is P of O." means "O P S." (inverse; equivalent to "<-")
-                this.next(); // consume "is"
-                verb = this.parseTerm();
-                if (!(this.peek().typ === 'Ident' && (this.peek().value || '') === 'of')) {
-                    this.fail(`Expected 'of' after 'is <expr>', got ${this.peek().toString()}`);
-                }
-                this.next(); // consume "of"
-                invert = true;
-            }
-            else if (this.peek().typ === 'OpPredInvert') {
-                this.next(); // "<-"
-                verb = this.parseTerm();
-                invert = true;
-            }
-            else {
-                verb = this.parseTerm();
-            }
-            const objects = this.parseObjectList();
-            // If VERB or OBJECTS contained paths, their helper triples must come
-            // before the triples that consume the path results (Easter depends on this).
-            if (this.pendingTriples.length > 0) {
-                out.push(...this.pendingTriples);
-                this.pendingTriples = [];
-            }
-            for (const o of objects) {
-                out.push(new Triple(invert ? o : subject, verb, invert ? subject : o));
-            }
-            if (this.peek().typ === 'Semicolon') {
-                this.next();
-                if (this.peek().typ === 'Dot')
-                    break;
-                continue;
-            }
-            break;
-        }
-        return out;
+    tokens.push(new Token('EOF', null, n));
+    return tokens;
+}
+// ===========================================================================
+// PREFIX ENVIRONMENT
+// ===========================================================================
+class PrefixEnv {
+    constructor(map, baseIri) {
+        this.map = map || {}; // prefix -> IRI (including "" for @prefix :)
+        this.baseIri = baseIri || ''; // base IRI for resolving <relative>
     }
-    parseObjectList() {
-        const objs = [this.parseTerm()];
-        while (this.peek().typ === 'Comma') {
-            this.next();
-            objs.push(this.parseTerm());
-        }
-        return objs;
+    static newDefault() {
+        const m = {};
+        m['rdf'] = RDF_NS;
+        m['rdfs'] = RDFS_NS;
+        m['xsd'] = XSD_NS;
+        m['log'] = LOG_NS;
+        m['math'] = MATH_NS;
+        m['string'] = STRING_NS;
+        m['list'] = LIST_NS;
+        m['time'] = TIME_NS;
+        m['genid'] = SKOLEM_NS;
+        m[''] = ''; // empty prefix default namespace
+        return new PrefixEnv(m, ''); // base IRI starts empty
     }
-    makeRule(left, right, isForward) {
-        let premiseTerm, conclTerm;
-        if (isForward) {
-            premiseTerm = left;
-            conclTerm = right;
-        }
-        else {
-            premiseTerm = right;
-            conclTerm = left;
+    set(pref, base) {
+        this.map[pref] = base;
+    }
+    setBase(baseIri) {
+        this.baseIri = baseIri || '';
+    }
+    expandQName(q) {
+        if (q.includes(':')) {
+            const [p, local] = q.split(':', 2);
+            const base = this.map[p] || '';
+            if (base)
+                return base + local;
+            return q;
         }
-        let isFuse = false;
-        if (isForward) {
-            if (conclTerm instanceof Literal && conclTerm.value === 'false') {
-                isFuse = true;
+        return q;
+    }
+    shrinkIri(iri) {
+        let best = null; // [prefix, local]
+        for (const [p, base] of Object.entries(this.map)) {
+            if (!base)
+                continue;
+            if (iri.startsWith(base)) {
+                const local = iri.slice(base.length);
+                if (!local)
+                    continue;
+                const cand = [p, local];
+                if (best === null || cand[1].length < best[1].length)
+                    best = cand;
             }
         }
-        let rawPremise;
-        if (premiseTerm instanceof GraphTerm) {
-            rawPremise = premiseTerm.triples;
-        }
-        else if (premiseTerm instanceof Literal && premiseTerm.value === 'true') {
-            rawPremise = [];
-        }
-        else {
-            rawPremise = [];
-        }
-        let rawConclusion;
-        if (conclTerm instanceof GraphTerm) {
-            rawConclusion = conclTerm.triples;
-        }
-        else if (conclTerm instanceof Literal && conclTerm.value === 'false') {
-            rawConclusion = [];
-        }
-        else {
-            rawConclusion = [];
-        }
-        // Blank nodes that occur explicitly in the head (conclusion)
-        const headBlankLabels = collectBlankLabelsInTriples(rawConclusion);
-        const [premise0, conclusion] = liftBlankRuleVars(rawPremise, rawConclusion);
-        // Reorder constraints for *forward* rules.
-        const premise = isForward ? reorderPremiseForConstraints(premise0) : premise0;
-        return new Rule(premise, conclusion, isForward, isFuse, headBlankLabels);
+        if (best === null)
+            return null;
+        const [p, local] = best;
+        if (p === '')
+            return `:${local}`;
+        return `${p}:${local}`;
     }
-}
-// ===========================================================================
-// Blank-node lifting and Skolemization
-// ===========================================================================
-function liftBlankRuleVars(premise, conclusion) {
-    function convertTerm(t, mapping, counter) {
-        if (t instanceof Blank) {
-            const label = t.label;
-            if (!mapping.hasOwnProperty(label)) {
-                counter[0] += 1;
-                mapping[label] = `_b${counter[0]}`;
+    prefixesUsedForOutput(triples) {
+        const used = new Set();
+        for (const t of triples) {
+            const iris = [];
+            iris.push(...collectIrisInTerm(t.s));
+            if (!isRdfTypePred(t.p)) {
+                iris.push(...collectIrisInTerm(t.p));
+            }
+            iris.push(...collectIrisInTerm(t.o));
+            for (const iri of iris) {
+                for (const [p, base] of Object.entries(this.map)) {
+                    if (base && iri.startsWith(base))
+                        used.add(p);
+                }
             }
-            return new Var(mapping[label]);
-        }
-        if (t instanceof ListTerm) {
-            return new ListTerm(t.elems.map((e) => convertTerm(e, mapping, counter)));
-        }
-        if (t instanceof OpenListTerm) {
-            return new OpenListTerm(t.prefix.map((e) => convertTerm(e, mapping, counter)), t.tailVar);
         }
-        if (t instanceof GraphTerm) {
-            const triples = t.triples.map((tr) => new Triple(convertTerm(tr.s, mapping, counter), convertTerm(tr.p, mapping, counter), convertTerm(tr.o, mapping, counter)));
-            return new GraphTerm(triples);
+        const v = [];
+        for (const p of used) {
+            if (this.map.hasOwnProperty(p))
+                v.push([p, this.map[p]]);
         }
-        return t;
-    }
-    function convertTriple(tr, mapping, counter) {
-        return new Triple(convertTerm(tr.s, mapping, counter), convertTerm(tr.p, mapping, counter), convertTerm(tr.o, mapping, counter));
+        v.sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0));
+        return v;
     }
-    const mapping = {};
-    const counter = [0];
-    const newPremise = premise.map((tr) => convertTriple(tr, mapping, counter));
-    return [newPremise, conclusion];
 }
-// Skolemization for blank nodes that occur explicitly in a rule head.
-//
-// IMPORTANT: we must be *stable per rule firing*, otherwise a rule whose
-// premises stay true would keep generating fresh _:sk_N blank nodes on every
-// outer fixpoint iteration (non-termination once we do strict duplicate checks).
-//
-// We achieve this by optionally keying head-blank allocations by a "firingKey"
-// (usually derived from the instantiated premises and rule index) and caching
-// them in a run-global map.
-function skolemizeTermForHeadBlanks(t, headBlankLabels, mapping, skCounter, firingKey, globalMap) {
-    if (t instanceof Blank) {
-        const label = t.label;
-        // Only skolemize blanks that occur explicitly in the rule head
-        if (!headBlankLabels || !headBlankLabels.has(label)) {
-            return t; // this is a data blank (e.g. bound via ?X), keep it
-        }
-        if (!mapping.hasOwnProperty(label)) {
-            // If we have a global cache keyed by firingKey, use it to ensure
-            // deterministic blank IDs for the same rule+substitution instance.
-            if (globalMap && firingKey) {
-                const gk = `${firingKey}|${label}`;
-                let sk = globalMap.get(gk);
-                if (!sk) {
-                    const idx = skCounter[0];
-                    skCounter[0] += 1;
-                    sk = `_:sk_${idx}`;
-                    globalMap.set(gk, sk);
-                }
-                mapping[label] = sk;
-            }
-            else {
-                const idx = skCounter[0];
-                skCounter[0] += 1;
-                mapping[label] = `_:sk_${idx}`;
-            }
-        }
-        return new Blank(mapping[label]);
+function collectIrisInTerm(t) {
+    const out = [];
+    if (t instanceof Iri) {
+        out.push(t.value);
     }
-    if (t instanceof ListTerm) {
-        return new ListTerm(t.elems.map((e) => skolemizeTermForHeadBlanks(e, headBlankLabels, mapping, skCounter, firingKey, globalMap)));
+    else if (t instanceof Literal) {
+        const [_lex, dt] = literalParts(t.value);
+        if (dt)
+            out.push(dt); // so rdf/xsd prefixes are emitted when only used in ^^...
     }
-    if (t instanceof OpenListTerm) {
-        return new OpenListTerm(t.prefix.map((e) => skolemizeTermForHeadBlanks(e, headBlankLabels, mapping, skCounter, firingKey, globalMap)), t.tailVar);
+    else if (t instanceof ListTerm) {
+        for (const x of t.elems)
+            out.push(...collectIrisInTerm(x));
     }
-    if (t instanceof GraphTerm) {
-        return new GraphTerm(t.triples.map((tr) => skolemizeTripleForHeadBlanks(tr, headBlankLabels, mapping, skCounter, firingKey, globalMap)));
+    else if (t instanceof OpenListTerm) {
+        for (const x of t.prefix)
+            out.push(...collectIrisInTerm(x));
     }
-    return t;
-}
-function skolemizeTripleForHeadBlanks(tr, headBlankLabels, mapping, skCounter, firingKey, globalMap) {
-    return new Triple(skolemizeTermForHeadBlanks(tr.s, headBlankLabels, mapping, skCounter, firingKey, globalMap), skolemizeTermForHeadBlanks(tr.p, headBlankLabels, mapping, skCounter, firingKey, globalMap), skolemizeTermForHeadBlanks(tr.o, headBlankLabels, mapping, skCounter, firingKey, globalMap));
-}
-// ===========================================================================
-// Alpha equivalence helpers
-// ===========================================================================
-function termsEqual(a, b) {
-    if (a === b)
-        return true;
-    if (!a || !b)
-        return false;
-    if (a.constructor !== b.constructor)
-        return false;
-    if (a instanceof Iri)
-        return a.value === b.value;
-    if (a instanceof Literal) {
-        if (a.value === b.value)
-            return true;
-        // Plain "abc" == "abc"^^xsd:string (but not language-tagged strings)
-        if (literalsEquivalentAsXsdString(a.value, b.value))
-            return true;
-        // Keep in sync with unifyTerm(): numeric-value equality, datatype-aware.
-        const ai = parseNumericLiteralInfo(a);
-        const bi = parseNumericLiteralInfo(b);
-        if (ai && bi) {
-            // Same datatype => compare values
-            if (ai.dt === bi.dt) {
-                if (ai.kind === 'bigint' && bi.kind === 'bigint')
-                    return ai.value === bi.value;
-                const an = ai.kind === 'bigint' ? Number(ai.value) : ai.value;
-                const bn = bi.kind === 'bigint' ? Number(bi.value) : bi.value;
-                return !Number.isNaN(an) && !Number.isNaN(bn) && an === bn;
-            }
+    else if (t instanceof GraphTerm) {
+        for (const tr of t.triples) {
+            out.push(...collectIrisInTerm(tr.s));
+            out.push(...collectIrisInTerm(tr.p));
+            out.push(...collectIrisInTerm(tr.o));
         }
-        return false;
     }
-    if (a instanceof Var)
-        return a.name === b.name;
-    if (a instanceof Blank)
-        return a.label === b.label;
-    if (a instanceof ListTerm) {
-        if (a.elems.length !== b.elems.length)
-            return false;
-        for (let i = 0; i < a.elems.length; i++) {
-            if (!termsEqual(a.elems[i], b.elems[i]))
-                return false;
-        }
-        return true;
+    return out;
+}
+function collectVarsInTerm(t, acc) {
+    if (t instanceof Var) {
+        acc.add(t.name);
     }
-    if (a instanceof OpenListTerm) {
-        if (a.tailVar !== b.tailVar)
-            return false;
-        if (a.prefix.length !== b.prefix.length)
-            return false;
-        for (let i = 0; i < a.prefix.length; i++) {
-            if (!termsEqual(a.prefix[i], b.prefix[i]))
-                return false;
+    else if (t instanceof ListTerm) {
+        for (const x of t.elems)
+            collectVarsInTerm(x, acc);
+    }
+    else if (t instanceof OpenListTerm) {
+        for (const x of t.prefix)
+            collectVarsInTerm(x, acc);
+        acc.add(t.tailVar);
+    }
+    else if (t instanceof GraphTerm) {
+        for (const tr of t.triples) {
+            collectVarsInTerm(tr.s, acc);
+            collectVarsInTerm(tr.p, acc);
+            collectVarsInTerm(tr.o, acc);
         }
-        return true;
     }
-    if (a instanceof GraphTerm) {
-        return alphaEqGraphTriples(a.triples, b.triples);
+}
+function varsInRule(rule) {
+    const acc = new Set();
+    for (const tr of rule.premise) {
+        collectVarsInTerm(tr.s, acc);
+        collectVarsInTerm(tr.p, acc);
+        collectVarsInTerm(tr.o, acc);
     }
-    return false;
+    for (const tr of rule.conclusion) {
+        collectVarsInTerm(tr.s, acc);
+        collectVarsInTerm(tr.p, acc);
+        collectVarsInTerm(tr.o, acc);
+    }
+    return acc;
 }
-function termsEqualNoIntDecimal(a, b) {
-    if (a === b)
-        return true;
-    if (!a || !b)
-        return false;
-    if (a.constructor !== b.constructor)
-        return false;
-    if (a instanceof Iri)
-        return a.value === b.value;
-    if (a instanceof Literal) {
-        if (a.value === b.value)
-            return true;
-        // Plain "abc" == "abc"^^xsd:string (but not language-tagged)
-        if (literalsEquivalentAsXsdString(a.value, b.value))
-            return true;
-        // Numeric equality ONLY when datatypes agree (no integer<->decimal here)
-        const ai = parseNumericLiteralInfo(a);
-        const bi = parseNumericLiteralInfo(b);
-        if (ai && bi && ai.dt === bi.dt) {
-            // integer: exact bigint
-            if (ai.kind === 'bigint' && bi.kind === 'bigint')
-                return ai.value === bi.value;
-            // decimal: compare exactly via num/scale if possible
-            if (ai.dt === XSD_NS + 'decimal') {
-                const da = parseXsdDecimalToBigIntScale(ai.lexStr);
-                const db = parseXsdDecimalToBigIntScale(bi.lexStr);
-                if (da && db) {
-                    const scale = Math.max(da.scale, db.scale);
-                    const na = da.num * pow10n(scale - da.scale);
-                    const nb = db.num * pow10n(scale - db.scale);
-                    return na === nb;
-                }
-            }
-            // double/float-ish: JS number (same as your normal same-dt path)
-            const an = ai.kind === 'bigint' ? Number(ai.value) : ai.value;
-            const bn = bi.kind === 'bigint' ? Number(bi.value) : bi.value;
-            return !Number.isNaN(an) && !Number.isNaN(bn) && an === bn;
-        }
-        return false;
+function collectBlankLabelsInTerm(t, acc) {
+    if (t instanceof Blank) {
+        acc.add(t.label);
     }
-    if (a instanceof Var)
-        return a.name === b.name;
-    if (a instanceof Blank)
-        return a.label === b.label;
-    if (a instanceof ListTerm) {
-        if (a.elems.length !== b.elems.length)
-            return false;
-        for (let i = 0; i < a.elems.length; i++) {
-            if (!termsEqualNoIntDecimal(a.elems[i], b.elems[i]))
-                return false;
-        }
-        return true;
+    else if (t instanceof ListTerm) {
+        for (const x of t.elems)
+            collectBlankLabelsInTerm(x, acc);
     }
-    if (a instanceof OpenListTerm) {
-        if (a.tailVar !== b.tailVar)
-            return false;
-        if (a.prefix.length !== b.prefix.length)
-            return false;
-        for (let i = 0; i < a.prefix.length; i++) {
-            if (!termsEqualNoIntDecimal(a.prefix[i], b.prefix[i]))
-                return false;
-        }
-        return true;
+    else if (t instanceof OpenListTerm) {
+        for (const x of t.prefix)
+            collectBlankLabelsInTerm(x, acc);
     }
-    if (a instanceof GraphTerm) {
-        return alphaEqGraphTriples(a.triples, b.triples);
+    else if (t instanceof GraphTerm) {
+        for (const tr of t.triples) {
+            collectBlankLabelsInTerm(tr.s, acc);
+            collectBlankLabelsInTerm(tr.p, acc);
+            collectBlankLabelsInTerm(tr.o, acc);
+        }
     }
-    return false;
 }
-function triplesEqual(a, b) {
-    return termsEqual(a.s, b.s) && termsEqual(a.p, b.p) && termsEqual(a.o, b.o);
-}
-function triplesListEqual(xs, ys) {
-    if (xs.length !== ys.length)
-        return false;
-    for (let i = 0; i < xs.length; i++) {
-        if (!triplesEqual(xs[i], ys[i]))
-            return false;
+function collectBlankLabelsInTriples(triples) {
+    const acc = new Set();
+    for (const tr of triples) {
+        collectBlankLabelsInTerm(tr.s, acc);
+        collectBlankLabelsInTerm(tr.p, acc);
+        collectBlankLabelsInTerm(tr.o, acc);
     }
-    return true;
-}
-// Alpha-equivalence for quoted formulas, up to *variable* and blank-node renaming.
-// Treats a formula as an unordered set of triples (order-insensitive match).
-function alphaEqVarName(x, y, vmap) {
-    if (vmap.hasOwnProperty(x))
-        return vmap[x] === y;
-    vmap[x] = y;
-    return true;
+    return acc;
 }
-function alphaEqTermInGraph(a, b, vmap, bmap) {
-    // Blank nodes: renamable
-    if (a instanceof Blank && b instanceof Blank) {
-        const x = a.label;
-        const y = b.label;
-        if (bmap.hasOwnProperty(x))
-            return bmap[x] === y;
-        bmap[x] = y;
-        return true;
+// ===========================================================================
+// PARSER
+// ===========================================================================
+class Parser {
+    constructor(tokens) {
+        this.toks = tokens;
+        this.pos = 0;
+        this.prefixes = PrefixEnv.newDefault();
+        this.blankCounter = 0;
+        this.pendingTriples = [];
     }
-    // Variables: renamable (ONLY inside quoted formulas)
-    if (a instanceof Var && b instanceof Var) {
-        return alphaEqVarName(a.name, b.name, vmap);
+    peek() {
+        return this.toks[this.pos];
     }
-    if (a instanceof Iri && b instanceof Iri)
-        return a.value === b.value;
-    if (a instanceof Literal && b instanceof Literal)
-        return a.value === b.value;
-    if (a instanceof ListTerm && b instanceof ListTerm) {
-        if (a.elems.length !== b.elems.length)
-            return false;
-        for (let i = 0; i < a.elems.length; i++) {
-            if (!alphaEqTermInGraph(a.elems[i], b.elems[i], vmap, bmap))
-                return false;
+    next() {
+        const tok = this.toks[this.pos];
+        this.pos += 1;
+        return tok;
+    }
+    fail(message, tok = this.peek()) {
+        const off = tok && typeof tok.offset === 'number' ? tok.offset : null;
+        throw new N3SyntaxError(message, off);
+    }
+    expectDot() {
+        const tok = this.next();
+        if (tok.typ !== 'Dot') {
+            this.fail(`Expected '.', got ${tok.toString()}`, tok);
         }
-        return true;
     }
-    if (a instanceof OpenListTerm && b instanceof OpenListTerm) {
-        if (a.prefix.length !== b.prefix.length)
-            return false;
-        for (let i = 0; i < a.prefix.length; i++) {
-            if (!alphaEqTermInGraph(a.prefix[i], b.prefix[i], vmap, bmap))
-                return false;
+    parseDocument() {
+        const triples = [];
+        const forwardRules = [];
+        const backwardRules = [];
+        while (this.peek().typ !== 'EOF') {
+            if (this.peek().typ === 'AtPrefix') {
+                this.next();
+                this.parsePrefixDirective();
+            }
+            else if (this.peek().typ === 'AtBase') {
+                this.next();
+                this.parseBaseDirective();
+            }
+            else if (
+            // SPARQL-style/Turtle-style directives (case-insensitive, no trailing '.')
+            this.peek().typ === 'Ident' &&
+                typeof this.peek().value === 'string' &&
+                this.peek().value.toLowerCase() === 'prefix' &&
+                this.toks[this.pos + 1] &&
+                this.toks[this.pos + 1].typ === 'Ident' &&
+                typeof this.toks[this.pos + 1].value === 'string' &&
+                // Require PNAME_NS form (e.g., "ex:" or ":") to avoid clashing with a normal triple starting with IRI "prefix".
+                this.toks[this.pos + 1].value.endsWith(':') &&
+                this.toks[this.pos + 2] &&
+                (this.toks[this.pos + 2].typ === 'IriRef' || this.toks[this.pos + 2].typ === 'Ident')) {
+                this.next(); // consume PREFIX keyword
+                this.parseSparqlPrefixDirective();
+            }
+            else if (this.peek().typ === 'Ident' &&
+                typeof this.peek().value === 'string' &&
+                this.peek().value.toLowerCase() === 'base' &&
+                this.toks[this.pos + 1] &&
+                // SPARQL BASE requires an IRIREF.
+                this.toks[this.pos + 1].typ === 'IriRef') {
+                this.next(); // consume BASE keyword
+                this.parseSparqlBaseDirective();
+            }
+            else {
+                const first = this.parseTerm();
+                if (this.peek().typ === 'OpImplies') {
+                    this.next();
+                    const second = this.parseTerm();
+                    this.expectDot();
+                    forwardRules.push(this.makeRule(first, second, true));
+                }
+                else if (this.peek().typ === 'OpImpliedBy') {
+                    this.next();
+                    const second = this.parseTerm();
+                    this.expectDot();
+                    backwardRules.push(this.makeRule(first, second, false));
+                }
+                else {
+                    let more;
+                    if (this.peek().typ === 'Dot') {
+                        // N3 grammar allows: triples ::= subject predicateObjectList?
+                        // So a bare subject followed by '.' is syntactically valid.
+                        // If the subject was a path / property-list that generated helper triples,
+                        // we emit those; otherwise this statement contributes no triples.
+                        more = [];
+                        if (this.pendingTriples.length > 0) {
+                            more = this.pendingTriples;
+                            this.pendingTriples = [];
+                        }
+                        this.next(); // consume '.'
+                    }
+                    else {
+                        more = this.parsePredicateObjectList(first);
+                        this.expectDot();
+                    }
+                    // normalize explicit log:implies / log:impliedBy at top-level
+                    for (const tr of more) {
+                        if (isLogImplies(tr.p) && tr.s instanceof GraphTerm && tr.o instanceof GraphTerm) {
+                            forwardRules.push(this.makeRule(tr.s, tr.o, true));
+                        }
+                        else if (isLogImpliedBy(tr.p) && tr.s instanceof GraphTerm && tr.o instanceof GraphTerm) {
+                            backwardRules.push(this.makeRule(tr.s, tr.o, false));
+                        }
+                        else {
+                            triples.push(tr);
+                        }
+                    }
+                }
+            }
         }
-        // tailVar is a var-name string, so treat it as renamable too
-        return alphaEqVarName(a.tailVar, b.tailVar, vmap);
-    }
-    // Nested formulas: compare with fresh maps (separate scope)
-    if (a instanceof GraphTerm && b instanceof GraphTerm) {
-        return alphaEqGraphTriples(a.triples, b.triples);
+        return [this.prefixes, triples, forwardRules, backwardRules];
     }
-    return false;
-}
-function alphaEqTripleInGraph(a, b, vmap, bmap) {
-    return (alphaEqTermInGraph(a.s, b.s, vmap, bmap) &&
-        alphaEqTermInGraph(a.p, b.p, vmap, bmap) &&
-        alphaEqTermInGraph(a.o, b.o, vmap, bmap));
-}
-function alphaEqGraphTriples(xs, ys) {
-    if (xs.length !== ys.length)
-        return false;
-    // Fast path: exact same sequence.
-    if (triplesListEqual(xs, ys))
-        return true;
-    // Order-insensitive backtracking match, threading var/blank mappings.
-    const used = new Array(ys.length).fill(false);
-    function step(i, vmap, bmap) {
-        if (i >= xs.length)
-            return true;
-        const x = xs[i];
-        for (let j = 0; j < ys.length; j++) {
-            if (used[j])
-                continue;
-            const y = ys[j];
-            // Cheap pruning when both predicates are IRIs.
-            if (x.p instanceof Iri && y.p instanceof Iri && x.p.value !== y.p.value)
-                continue;
-            const v2 = { ...vmap };
-            const b2 = { ...bmap };
-            if (!alphaEqTripleInGraph(x, y, v2, b2))
-                continue;
-            used[j] = true;
-            if (step(i + 1, v2, b2))
-                return true;
-            used[j] = false;
+    parsePrefixDirective() {
+        const tok = this.next();
+        if (tok.typ !== 'Ident') {
+            this.fail(`Expected prefix name, got ${tok.toString()}`, tok);
         }
-        return false;
+        const pref = tok.value || '';
+        const prefName = pref.endsWith(':') ? pref.slice(0, -1) : pref;
+        if (this.peek().typ === 'Dot') {
+            this.next();
+            if (!this.prefixes.map.hasOwnProperty(prefName)) {
+                this.prefixes.set(prefName, '');
+            }
+            return;
+        }
+        const tok2 = this.next();
+        let iri;
+        if (tok2.typ === 'IriRef') {
+            iri = resolveIriRef(tok2.value || '', this.prefixes.baseIri || '');
+        }
+        else if (tok2.typ === 'Ident') {
+            iri = this.prefixes.expandQName(tok2.value || '');
+        }
+        else {
+            this.fail(`Expected IRI after @prefix, got ${tok2.toString()}`, tok2);
+        }
+        this.expectDot();
+        this.prefixes.set(prefName, iri);
     }
-    return step(0, {}, {});
-}
-function alphaEqTerm(a, b, bmap) {
-    if (a instanceof Blank && b instanceof Blank) {
-        const x = a.label;
-        const y = b.label;
-        if (bmap.hasOwnProperty(x)) {
-            return bmap[x] === y;
+    parseBaseDirective() {
+        const tok = this.next();
+        let iri;
+        if (tok.typ === 'IriRef') {
+            iri = resolveIriRef(tok.value || '', this.prefixes.baseIri || '');
+        }
+        else if (tok.typ === 'Ident') {
+            iri = tok.value || '';
         }
         else {
-            bmap[x] = y;
-            return true;
+            this.fail(`Expected IRI after @base, got ${tok.toString()}`, tok);
         }
+        this.expectDot();
+        this.prefixes.setBase(iri);
     }
-    if (a instanceof Iri && b instanceof Iri)
-        return a.value === b.value;
-    if (a instanceof Literal && b instanceof Literal)
-        return a.value === b.value;
-    if (a instanceof Var && b instanceof Var)
-        return a.name === b.name;
-    if (a instanceof ListTerm && b instanceof ListTerm) {
-        if (a.elems.length !== b.elems.length)
-            return false;
-        for (let i = 0; i < a.elems.length; i++) {
-            if (!alphaEqTerm(a.elems[i], b.elems[i], bmap))
-                return false;
+    parseSparqlPrefixDirective() {
+        // SPARQL/Turtle-style PREFIX directive: PREFIX pfx: <iri>  (no trailing '.')
+        const tok = this.next();
+        if (tok.typ !== 'Ident') {
+            this.fail(`Expected prefix name after PREFIX, got ${tok.toString()}`, tok);
         }
-        return true;
+        const pref = tok.value || '';
+        const prefName = pref.endsWith(':') ? pref.slice(0, -1) : pref;
+        const tok2 = this.next();
+        let iri;
+        if (tok2.typ === 'IriRef') {
+            iri = resolveIriRef(tok2.value || '', this.prefixes.baseIri || '');
+        }
+        else if (tok2.typ === 'Ident') {
+            iri = this.prefixes.expandQName(tok2.value || '');
+        }
+        else {
+            this.fail(`Expected IRI after PREFIX, got ${tok2.toString()}`, tok2);
+        }
+        // N3/Turtle: PREFIX directives do not have a trailing '.', but accept it permissively.
+        if (this.peek().typ === 'Dot')
+            this.next();
+        this.prefixes.set(prefName, iri);
     }
-    if (a instanceof OpenListTerm && b instanceof OpenListTerm) {
-        if (a.tailVar !== b.tailVar || a.prefix.length !== b.prefix.length)
-            return false;
-        for (let i = 0; i < a.prefix.length; i++) {
-            if (!alphaEqTerm(a.prefix[i], b.prefix[i], bmap))
-                return false;
+    parseSparqlBaseDirective() {
+        // SPARQL/Turtle-style BASE directive: BASE <iri>  (no trailing '.')
+        const tok = this.next();
+        let iri;
+        if (tok.typ === 'IriRef') {
+            iri = resolveIriRef(tok.value || '', this.prefixes.baseIri || '');
         }
-        return true;
+        else if (tok.typ === 'Ident') {
+            iri = tok.value || '';
+        }
+        else {
+            this.fail(`Expected IRI after BASE, got ${tok.toString()}`, tok);
+        }
+        // N3/Turtle: BASE directives do not have a trailing '.', but accept it permissively.
+        if (this.peek().typ === 'Dot')
+            this.next();
+        this.prefixes.setBase(iri);
     }
-    if (a instanceof GraphTerm && b instanceof GraphTerm) {
-        // formulas are alpha-equivalent up to var/blank renaming
-        return alphaEqGraphTriples(a.triples, b.triples);
+    parseTerm() {
+        let t = this.parsePathItem();
+        while (this.peek().typ === 'OpPathFwd' || this.peek().typ === 'OpPathRev') {
+            const dir = this.next().typ; // OpPathFwd | OpPathRev
+            const pred = this.parsePathItem();
+            this.blankCounter += 1;
+            const bn = new Blank(`_:b${this.blankCounter}`);
+            this.pendingTriples.push(dir === 'OpPathFwd' ? new Triple(t, pred, bn) : new Triple(bn, pred, t));
+            t = bn;
+        }
+        return t;
     }
-    return false;
-}
-function alphaEqTriple(a, b) {
-    const bmap = {};
-    return alphaEqTerm(a.s, b.s, bmap) && alphaEqTerm(a.p, b.p, bmap) && alphaEqTerm(a.o, b.o, bmap);
-}
-// ===========================================================================
-// Indexes (facts + backward rules)
-// ===========================================================================
-//
-// Facts:
-//   - __byPred: Map<predicateIRI, Triple[]>
-//   - __byPO:   Map<predicateIRI, Map<objectKey, Triple[]>>
-//   - __keySet: Set<"S\tP\tO"> for IRI/Literal-only triples (fast dup check)
-//
-// Backward rules:
-//   - __byHeadPred:   Map<headPredicateIRI, Rule[]>
-//   - __wildHeadPred: Rule[] (non-IRI head predicate)
-function termFastKey(t) {
-    if (t instanceof Iri)
-        return 'I:' + t.value;
-    if (t instanceof Literal)
-        return 'L:' + normalizeLiteralForFastKey(t.value);
-    return null;
-}
-function tripleFastKey(tr) {
-    const ks = termFastKey(tr.s);
-    const kp = termFastKey(tr.p);
-    const ko = termFastKey(tr.o);
-    if (ks === null || kp === null || ko === null)
-        return null;
-    return ks + '\t' + kp + '\t' + ko;
-}
-function ensureFactIndexes(facts) {
-    if (facts.__byPred && facts.__byPS && facts.__byPO && facts.__keySet)
-        return;
-    Object.defineProperty(facts, '__byPred', {
-        value: new Map(),
-        enumerable: false,
-        writable: true,
-    });
-    Object.defineProperty(facts, '__byPS', {
-        value: new Map(),
-        enumerable: false,
-        writable: true,
-    });
-    Object.defineProperty(facts, '__byPO', {
-        value: new Map(),
-        enumerable: false,
-        writable: true,
-    });
-    Object.defineProperty(facts, '__keySet', {
-        value: new Set(),
-        enumerable: false,
-        writable: true,
-    });
-    for (const f of facts)
-        indexFact(facts, f);
-}
-function indexFact(facts, tr) {
-    if (tr.p instanceof Iri) {
-        const pk = tr.p.value;
-        let pb = facts.__byPred.get(pk);
-        if (!pb) {
-            pb = [];
-            facts.__byPred.set(pk, pb);
+    parsePathItem() {
+        const tok = this.next();
+        const typ = tok.typ;
+        const val = tok.value;
+        if (typ === 'Equals') {
+            return internIri(OWL_NS + 'sameAs');
         }
-        pb.push(tr);
-        const sk = termFastKey(tr.s);
-        if (sk !== null) {
-            let ps = facts.__byPS.get(pk);
-            if (!ps) {
-                ps = new Map();
-                facts.__byPS.set(pk, ps);
+        if (typ === 'IriRef') {
+            const base = this.prefixes.baseIri || '';
+            return internIri(resolveIriRef(val || '', base));
+        }
+        if (typ === 'Ident') {
+            const name = val || '';
+            if (name === 'a') {
+                return internIri(RDF_NS + 'type');
             }
-            let psb = ps.get(sk);
-            if (!psb) {
-                psb = [];
-                ps.set(sk, psb);
+            else if (name.startsWith('_:')) {
+                return new Blank(name);
             }
-            psb.push(tr);
-        }
-        const ok = termFastKey(tr.o);
-        if (ok !== null) {
-            let po = facts.__byPO.get(pk);
-            if (!po) {
-                po = new Map();
-                facts.__byPO.set(pk, po);
+            else if (name.includes(':')) {
+                return internIri(this.prefixes.expandQName(name));
             }
-            let pob = po.get(ok);
-            if (!pob) {
-                pob = [];
-                po.set(ok, pob);
+            else {
+                return internIri(name);
             }
-            pob.push(tr);
-        }
-    }
-    const key = tripleFastKey(tr);
-    if (key !== null)
-        facts.__keySet.add(key);
-}
-function candidateFacts(facts, goal) {
-    ensureFactIndexes(facts);
-    if (goal.p instanceof Iri) {
-        const pk = goal.p.value;
-        const sk = termFastKey(goal.s);
-        const ok = termFastKey(goal.o);
-        /** @type {Triple[] | null} */
-        let byPS = null;
-        if (sk !== null) {
-            const ps = facts.__byPS.get(pk);
-            if (ps)
-                byPS = ps.get(sk) || null;
         }
-        /** @type {Triple[] | null} */
-        let byPO = null;
-        if (ok !== null) {
-            const po = facts.__byPO.get(pk);
-            if (po)
-                byPO = po.get(ok) || null;
-        }
-        if (byPS && byPO)
-            return byPS.length <= byPO.length ? byPS : byPO;
-        if (byPS)
-            return byPS;
-        if (byPO)
-            return byPO;
-        return facts.__byPred.get(pk) || [];
-    }
-    return facts;
-}
-function hasFactIndexed(facts, tr) {
-    ensureFactIndexes(facts);
-    const key = tripleFastKey(tr);
-    if (key !== null)
-        return facts.__keySet.has(key);
-    if (tr.p instanceof Iri) {
-        const pk = tr.p.value;
-        const ok = termFastKey(tr.o);
-        if (ok !== null) {
-            const po = facts.__byPO.get(pk);
-            if (po) {
-                const pob = po.get(ok) || [];
-                // Facts are all in the same graph. Different blank node labels represent
-                // different existentials unless explicitly connected. Do NOT treat
-                // triples as duplicates modulo blank renaming, or you'll incorrectly
-                // drop facts like: _:sk_0 :x 8.0  (because _:b8 :x 8.0 exists).
-                return pob.some((t) => triplesEqual(t, tr));
+        if (typ === 'Literal') {
+            let s = val || '';
+            // Optional language tag: "..."@en, per N3 LANGTAG production.
+            if (this.peek().typ === 'LangTag') {
+                // Only quoted string literals can carry a language tag.
+                if (!(s.startsWith('"') && s.endsWith('"'))) {
+                    this.fail('Language tag is only allowed on quoted string literals', this.peek());
+                }
+                const langTok = this.next();
+                const lang = langTok.value || '';
+                s = `${s}@${lang}`;
+                // N3/Turtle: language tags and datatypes are mutually exclusive.
+                if (this.peek().typ === 'HatHat') {
+                    this.fail('A literal cannot have both a language tag (@...) and a datatype (^^...)', this.peek());
+                }
+            }
+            if (this.peek().typ === 'HatHat') {
+                this.next();
+                const dtTok = this.next();
+                let dtIri;
+                if (dtTok.typ === 'IriRef') {
+                    dtIri = dtTok.value || '';
+                }
+                else if (dtTok.typ === 'Ident') {
+                    const qn = dtTok.value || '';
+                    if (qn.includes(':'))
+                        dtIri = this.prefixes.expandQName(qn);
+                    else
+                        dtIri = qn;
+                }
+                else {
+                    this.fail(`Expected datatype after ^^, got ${dtTok.toString()}`, dtTok);
+                }
+                s = `${s}^^<${dtIri}>`;
             }
+            return internLiteral(s);
         }
-        const pb = facts.__byPred.get(pk) || [];
-        return pb.some((t) => triplesEqual(t, tr));
+        if (typ === 'Var')
+            return new Var(val || '');
+        if (typ === 'LParen')
+            return this.parseList();
+        if (typ === 'LBracket')
+            return this.parseBlank();
+        if (typ === 'LBrace')
+            return this.parseGraph();
+        this.fail(`Unexpected term token: ${tok.toString()}`, tok);
     }
-    // Non-IRI predicate: fall back to strict triple equality.
-    return facts.some((t) => triplesEqual(t, tr));
-}
-function pushFactIndexed(facts, tr) {
-    ensureFactIndexes(facts);
-    facts.push(tr);
-    indexFact(facts, tr);
-}
-function ensureBackRuleIndexes(backRules) {
-    if (backRules.__byHeadPred && backRules.__wildHeadPred)
-        return;
-    Object.defineProperty(backRules, '__byHeadPred', {
-        value: new Map(),
-        enumerable: false,
-        writable: true,
-    });
-    Object.defineProperty(backRules, '__wildHeadPred', {
-        value: [],
-        enumerable: false,
-        writable: true,
-    });
-    for (const r of backRules)
-        indexBackRule(backRules, r);
-}
-function indexBackRule(backRules, r) {
-    if (!r || !r.conclusion || r.conclusion.length !== 1)
-        return;
-    const head = r.conclusion[0];
-    if (head && head.p instanceof Iri) {
-        const k = head.p.value;
-        let bucket = backRules.__byHeadPred.get(k);
-        if (!bucket) {
-            bucket = [];
-            backRules.__byHeadPred.set(k, bucket);
+    parseList() {
+        const elems = [];
+        while (this.peek().typ !== 'RParen') {
+            elems.push(this.parseTerm());
         }
-        bucket.push(r);
-    }
-    else {
-        backRules.__wildHeadPred.push(r);
-    }
-}
-// ===========================================================================
-// Special predicate helpers
-// ===========================================================================
-function isRdfTypePred(p) {
-    return p instanceof Iri && p.value === RDF_NS + 'type';
-}
-function isOwlSameAsPred(t) {
-    return t instanceof Iri && t.value === OWL_NS + 'sameAs';
-}
-function isLogImplies(p) {
-    return p instanceof Iri && p.value === LOG_NS + 'implies';
-}
-function isLogImpliedBy(p) {
-    return p instanceof Iri && p.value === LOG_NS + 'impliedBy';
-}
-// ===========================================================================
-// Constraint / "test" builtins
-// ===========================================================================
-function isConstraintBuiltin(tr) {
-    if (!(tr.p instanceof Iri))
-        return false;
-    const v = tr.p.value;
-    // math: numeric comparisons (no new bindings, just tests)
-    if (v === MATH_NS + 'equalTo' ||
-        v === MATH_NS + 'greaterThan' ||
-        v === MATH_NS + 'lessThan' ||
-        v === MATH_NS + 'notEqualTo' ||
-        v === MATH_NS + 'notGreaterThan' ||
-        v === MATH_NS + 'notLessThan') {
-        return true;
-    }
-    // list: membership test with no bindings
-    if (v === LIST_NS + 'notMember') {
-        return true;
-    }
-    // log: tests that are purely constraints (no new bindings)
-    if (v === LOG_NS + 'forAllIn' ||
-        v === LOG_NS + 'notEqualTo' ||
-        v === LOG_NS + 'notIncludes' ||
-        v === LOG_NS + 'outputString') {
-        return true;
-    }
-    // string: relational / membership style tests (no bindings)
-    if (v === STRING_NS + 'contains' ||
-        v === STRING_NS + 'containsIgnoringCase' ||
-        v === STRING_NS + 'endsWith' ||
-        v === STRING_NS + 'equalIgnoringCase' ||
-        v === STRING_NS + 'greaterThan' ||
-        v === STRING_NS + 'lessThan' ||
-        v === STRING_NS + 'matches' ||
-        v === STRING_NS + 'notEqualIgnoringCase' ||
-        v === STRING_NS + 'notGreaterThan' ||
-        v === STRING_NS + 'notLessThan' ||
-        v === STRING_NS + 'notMatches' ||
-        v === STRING_NS + 'startsWith') {
-        return true;
-    }
-    return false;
-}
-// Move constraint builtins to the end of the rule premise.
-// This is a simple "delaying" strategy similar in spirit to Prolog's when/2:
-// - normal goals first (can bind variables),
-// - pure test / constraint builtins last (checked once bindings are in place).
-function reorderPremiseForConstraints(premise) {
-    if (!premise || premise.length === 0)
-        return premise;
-    const normal = [];
-    const delayed = [];
-    for (const tr of premise) {
-        if (isConstraintBuiltin(tr))
-            delayed.push(tr);
-        else
-            normal.push(tr);
-    }
-    return normal.concat(delayed);
-}
-// @ts-nocheck
-/* eslint-disable */
-// ===========================================================================
-// Unification + substitution
-// ===========================================================================
-function containsVarTerm(t, v) {
-    if (t instanceof Var)
-        return t.name === v;
-    if (t instanceof ListTerm)
-        return t.elems.some((e) => containsVarTerm(e, v));
-    if (t instanceof OpenListTerm)
-        return t.prefix.some((e) => containsVarTerm(e, v)) || t.tailVar === v;
-    if (t instanceof GraphTerm)
-        return t.triples.some((tr) => containsVarTerm(tr.s, v) || containsVarTerm(tr.p, v) || containsVarTerm(tr.o, v));
-    return false;
-}
-function isGroundTermInGraph(t) {
-    // variables inside graph terms are treated as local placeholders,
-    // so they don't make the *surrounding triple* non-ground.
-    if (t instanceof OpenListTerm)
-        return false;
-    if (t instanceof ListTerm)
-        return t.elems.every((e) => isGroundTermInGraph(e));
-    if (t instanceof GraphTerm)
-        return t.triples.every((tr) => isGroundTripleInGraph(tr));
-    // Iri/Literal/Blank/Var are all OK inside formulas
-    return true;
-}
-function isGroundTripleInGraph(tr) {
-    return isGroundTermInGraph(tr.s) && isGroundTermInGraph(tr.p) && isGroundTermInGraph(tr.o);
-}
-function isGroundTerm(t) {
-    if (t instanceof Var)
-        return false;
-    if (t instanceof ListTerm)
-        return t.elems.every((e) => isGroundTerm(e));
-    if (t instanceof OpenListTerm)
-        return false;
-    if (t instanceof GraphTerm)
-        return t.triples.every((tr) => isGroundTripleInGraph(tr));
-    return true;
-}
-function isGroundTriple(tr) {
-    return isGroundTerm(tr.s) && isGroundTerm(tr.p) && isGroundTerm(tr.o);
-}
-// Canonical JSON-ish encoding for use as a Skolem cache key.
-// We only *call* this on ground terms in log:skolem, but it is
-// robust to seeing vars/open lists anyway.
-function skolemKeyFromTerm(t) {
-    function enc(u) {
-        if (u instanceof Iri)
-            return ['I', u.value];
-        if (u instanceof Literal)
-            return ['L', u.value];
-        if (u instanceof Blank)
-            return ['B', u.label];
-        if (u instanceof Var)
-            return ['V', u.name];
-        if (u instanceof ListTerm)
-            return ['List', u.elems.map(enc)];
-        if (u instanceof OpenListTerm)
-            return ['OpenList', u.prefix.map(enc), u.tailVar];
-        if (u instanceof GraphTerm)
-            return ['Graph', u.triples.map((tr) => [enc(tr.s), enc(tr.p), enc(tr.o)])];
-        return ['Other', String(u)];
+        this.next(); // consume ')'
+        return new ListTerm(elems);
     }
-    return JSON.stringify(enc(t));
-}
-function applySubstTerm(t, s) {
-    // Common case: variable
-    if (t instanceof Var) {
-        // Fast path: unbound variable → no change
-        const first = s[t.name];
-        if (first === undefined) {
-            return t;
+    parseBlank() {
+        // [] or [ ... ] property list
+        if (this.peek().typ === 'RBracket') {
+            this.next();
+            this.blankCounter += 1;
+            return new Blank(`_:b${this.blankCounter}`);
         }
-        // Follow chains X -> Y -> ... until we hit a non-var or a cycle.
-        let cur = first;
-        const seen = new Set([t.name]);
-        while (cur instanceof Var) {
-            const name = cur.name;
-            if (seen.has(name))
-                break; // cycle
-            seen.add(name);
-            const nxt = s[name];
-            if (!nxt)
+        // IRI property list: [ id <IRI> predicateObjectList? ]
+        // Lets you embed descriptions of an IRI directly in object position.
+        if (this.peek().typ === 'Ident' && (this.peek().value || '') === 'id') {
+            const iriTok = this.next(); // consume 'id'
+            const iriTerm = this.parseTerm();
+            // N3 note: 'id' form is not meant to be used with blank node identifiers.
+            if (iriTerm instanceof Blank && iriTerm.label.startsWith('_:')) {
+                this.fail("Cannot use 'id' keyword with a blank node identifier inside [...]", iriTok);
+            }
+            // Optional ';' right after the id IRI (tolerated).
+            if (this.peek().typ === 'Semicolon')
+                this.next();
+            // Empty IRI property list: [ id :iri ]
+            if (this.peek().typ === 'RBracket') {
+                this.next();
+                return iriTerm;
+            }
+            const subj = iriTerm;
+            while (true) {
+                let pred;
+                let invert = false;
+                if (this.peek().typ === 'Ident' && (this.peek().value || '') === 'a') {
+                    this.next();
+                    pred = internIri(RDF_NS + 'type');
+                }
+                else if (this.peek().typ === 'OpPredInvert') {
+                    this.next(); // "<-"
+                    pred = this.parseTerm();
+                    invert = true;
+                }
+                else {
+                    pred = this.parseTerm();
+                }
+                const objs = [this.parseTerm()];
+                while (this.peek().typ === 'Comma') {
+                    this.next();
+                    objs.push(this.parseTerm());
+                }
+                for (const o of objs) {
+                    this.pendingTriples.push(invert ? new Triple(o, pred, subj) : new Triple(subj, pred, o));
+                }
+                if (this.peek().typ === 'Semicolon') {
+                    this.next();
+                    if (this.peek().typ === 'RBracket')
+                        break;
+                    continue;
+                }
                 break;
-            cur = nxt;
-        }
-        if (cur instanceof Var) {
-            // Still a var: keep it as is (no need to clone)
-            return cur;
+            }
+            if (this.peek().typ !== 'RBracket') {
+                this.fail(`Expected ']' at end of IRI property list, got ${this.peek().toString()}`);
+            }
+            this.next();
+            return iriTerm;
         }
-        // Bound to a non-var term: apply substitution recursively in case it
-        // contains variables inside.
-        return applySubstTerm(cur, s);
-    }
-    // Non-variable terms
-    if (t instanceof ListTerm) {
-        return new ListTerm(t.elems.map((e) => applySubstTerm(e, s)));
-    }
-    if (t instanceof OpenListTerm) {
-        const newPrefix = t.prefix.map((e) => applySubstTerm(e, s));
-        const tailTerm = s[t.tailVar];
-        if (tailTerm !== undefined) {
-            const tailApplied = applySubstTerm(tailTerm, s);
-            if (tailApplied instanceof ListTerm) {
-                return new ListTerm(newPrefix.concat(tailApplied.elems));
+        // [ predicateObjectList ]
+        this.blankCounter += 1;
+        const id = `_:b${this.blankCounter}`;
+        const subj = new Blank(id);
+        while (true) {
+            // Verb (can also be 'a')
+            let pred;
+            let invert = false;
+            if (this.peek().typ === 'Ident' && (this.peek().value || '') === 'a') {
+                this.next();
+                pred = internIri(RDF_NS + 'type');
             }
-            else if (tailApplied instanceof OpenListTerm) {
-                return new OpenListTerm(newPrefix.concat(tailApplied.prefix), tailApplied.tailVar);
+            else if (this.peek().typ === 'OpPredInvert') {
+                this.next(); // consume "<-"
+                pred = this.parseTerm();
+                invert = true;
             }
             else {
-                return new OpenListTerm(newPrefix, t.tailVar);
+                pred = this.parseTerm();
+            }
+            // Object list: o1, o2, ...
+            const objs = [this.parseTerm()];
+            while (this.peek().typ === 'Comma') {
+                this.next();
+                objs.push(this.parseTerm());
+            }
+            for (const o of objs) {
+                this.pendingTriples.push(invert ? new Triple(o, pred, subj) : new Triple(subj, pred, o));
             }
+            if (this.peek().typ === 'Semicolon') {
+                this.next();
+                if (this.peek().typ === 'RBracket')
+                    break;
+                continue;
+            }
+            break;
         }
-        else {
-            return new OpenListTerm(newPrefix, t.tailVar);
+        if (this.peek().typ === 'RBracket') {
+            this.next();
         }
-    }
-    if (t instanceof GraphTerm) {
-        return new GraphTerm(t.triples.map((tr) => applySubstTriple(tr, s)));
-    }
-    return t;
-}
-function applySubstTriple(tr, s) {
-    return new Triple(applySubstTerm(tr.s, s), applySubstTerm(tr.p, s), applySubstTerm(tr.o, s));
-}
-function iriValue(t) {
-    return t instanceof Iri ? t.value : null;
-}
-function unifyOpenWithList(prefix, tailv, ys, subst) {
-    if (ys.length < prefix.length)
-        return null;
-    let s2 = { ...subst };
-    for (let i = 0; i < prefix.length; i++) {
-        s2 = unifyTerm(prefix[i], ys[i], s2);
-        if (s2 === null)
-            return null;
-    }
-    const rest = new ListTerm(ys.slice(prefix.length));
-    s2 = unifyTerm(new Var(tailv), rest, s2);
-    if (s2 === null)
-        return null;
-    return s2;
-}
-function unifyGraphTriples(xs, ys, subst) {
-    if (xs.length !== ys.length)
-        return null;
-    // Fast path: exact same sequence.
-    if (triplesListEqual(xs, ys))
-        return { ...subst };
-    // Backtracking match (order-insensitive), *threading* the substitution through.
-    const used = new Array(ys.length).fill(false);
-    function step(i, s) {
-        if (i >= xs.length)
-            return s;
-        const x = xs[i];
-        for (let j = 0; j < ys.length; j++) {
-            if (used[j])
-                continue;
-            const y = ys[j];
-            // Cheap pruning when both predicates are IRIs.
-            if (x.p instanceof Iri && y.p instanceof Iri && x.p.value !== y.p.value)
-                continue;
-            const s2 = unifyTriple(x, y, s); // IMPORTANT: use `s`, not {}
-            if (s2 === null)
-                continue;
-            used[j] = true;
-            const s3 = step(i + 1, s2);
-            if (s3 !== null)
-                return s3;
-            used[j] = false;
+        else {
+            this.fail(`Expected ']' at end of blank node property list, got ${this.peek().toString()}`);
         }
-        return null;
-    }
-    return step(0, { ...subst }); // IMPORTANT: start from the incoming subst
-}
-function unifyTerm(a, b, subst) {
-    return unifyTermWithOptions(a, b, subst, {
-        boolValueEq: true,
-        intDecimalEq: false,
-    });
-}
-function unifyTermListAppend(a, b, subst) {
-    // Keep list:append behavior: allow integer<->decimal exact equality,
-    // but do NOT add boolean-value equivalence (preserves current semantics).
-    return unifyTermWithOptions(a, b, subst, {
-        boolValueEq: false,
-        intDecimalEq: true,
-    });
-}
-function unifyTermWithOptions(a, b, subst, opts) {
-    a = applySubstTerm(a, subst);
-    b = applySubstTerm(b, subst);
-    // Variable binding
-    if (a instanceof Var) {
-        const v = a.name;
-        const t = b;
-        if (t instanceof Var && t.name === v)
-            return { ...subst };
-        if (containsVarTerm(t, v))
-            return null;
-        const s2 = { ...subst };
-        s2[v] = t;
-        return s2;
-    }
-    if (b instanceof Var) {
-        return unifyTermWithOptions(b, a, subst, opts);
-    }
-    // Exact matches
-    if (a instanceof Iri && b instanceof Iri && a.value === b.value)
-        return { ...subst };
-    if (a instanceof Literal && b instanceof Literal && a.value === b.value)
-        return { ...subst };
-    if (a instanceof Blank && b instanceof Blank && a.label === b.label)
-        return { ...subst };
-    // Plain string vs xsd:string equivalence
-    if (a instanceof Literal && b instanceof Literal) {
-        if (literalsEquivalentAsXsdString(a.value, b.value))
-            return { ...subst };
-    }
-    // Boolean-value equivalence (ONLY for normal unifyTerm)
-    if (opts.boolValueEq && a instanceof Literal && b instanceof Literal) {
-        const ai = parseBooleanLiteralInfo(a);
-        const bi = parseBooleanLiteralInfo(b);
-        if (ai && bi && ai.value === bi.value)
-            return { ...subst };
+        return new Blank(id);
     }
-    // Numeric-value match:
-    // - always allow equality when datatype matches (existing behavior)
-    // - optionally allow integer<->decimal exact equality (list:append only)
-    if (a instanceof Literal && b instanceof Literal) {
-        const ai = parseNumericLiteralInfo(a);
-        const bi = parseNumericLiteralInfo(b);
-        if (ai && bi) {
-            if (ai.dt === bi.dt) {
-                if (ai.kind === 'bigint' && bi.kind === 'bigint') {
-                    if (ai.value === bi.value)
-                        return { ...subst };
+    parseGraph() {
+        const triples = [];
+        while (this.peek().typ !== 'RBrace') {
+            const left = this.parseTerm();
+            if (this.peek().typ === 'OpImplies') {
+                this.next();
+                const right = this.parseTerm();
+                const pred = internIri(LOG_NS + 'implies');
+                triples.push(new Triple(left, pred, right));
+                if (this.peek().typ === 'Dot')
+                    this.next();
+                else if (this.peek().typ === 'RBrace') {
+                    // ok
                 }
                 else {
-                    const an = ai.kind === 'bigint' ? Number(ai.value) : ai.value;
-                    const bn = bi.kind === 'bigint' ? Number(bi.value) : bi.value;
-                    if (!Number.isNaN(an) && !Number.isNaN(bn) && an === bn)
-                        return { ...subst };
+                    this.fail(`Expected '.' or '}', got ${this.peek().toString()}`);
+                }
+            }
+            else if (this.peek().typ === 'OpImpliedBy') {
+                this.next();
+                const right = this.parseTerm();
+                const pred = internIri(LOG_NS + 'impliedBy');
+                triples.push(new Triple(left, pred, right));
+                if (this.peek().typ === 'Dot')
+                    this.next();
+                else if (this.peek().typ === 'RBrace') {
+                    // ok
+                }
+                else {
+                    this.fail(`Expected '.' or '}', got ${this.peek().toString()}`);
+                }
+            }
+            else {
+                // N3 grammar allows: triples ::= subject predicateObjectList?
+                // So a bare subject (optionally producing helper triples) is allowed inside formulas as well.
+                if (this.peek().typ === 'Dot' || this.peek().typ === 'RBrace') {
+                    if (this.pendingTriples.length > 0) {
+                        triples.push(...this.pendingTriples);
+                        this.pendingTriples = [];
+                    }
+                    if (this.peek().typ === 'Dot')
+                        this.next();
+                    continue;
+                }
+                triples.push(...this.parsePredicateObjectList(left));
+                if (this.peek().typ === 'Dot')
+                    this.next();
+                else if (this.peek().typ === 'RBrace') {
+                    // ok
                 }
+                else {
+                    this.fail(`Expected '.' or '}', got ${this.peek().toString()}`);
+                }
+            }
+        }
+        this.next(); // consume '}'
+        return new GraphTerm(triples);
+    }
+    parsePredicateObjectList(subject) {
+        const out = [];
+        // If the SUBJECT was a path, emit its helper triples first
+        if (this.pendingTriples.length > 0) {
+            out.push(...this.pendingTriples);
+            this.pendingTriples = [];
+        }
+        while (true) {
+            let verb;
+            let invert = false;
+            if (this.peek().typ === 'Ident' && (this.peek().value || '') === 'a') {
+                this.next();
+                verb = internIri(RDF_NS + 'type');
+            }
+            else if (this.peek().typ === 'Ident' && (this.peek().value || '') === 'has') {
+                // N3 syntactic sugar: "S has P O." means "S P O."
+                this.next(); // consume "has"
+                verb = this.parseTerm();
             }
-            if (opts.intDecimalEq) {
-                const intDt = XSD_NS + 'integer';
-                const decDt = XSD_NS + 'decimal';
-                if ((ai.dt === intDt && bi.dt === decDt) || (ai.dt === decDt && bi.dt === intDt)) {
-                    const intInfo = ai.dt === intDt ? ai : bi; // bigint
-                    const decInfo = ai.dt === decDt ? ai : bi; // number + lexStr
-                    const dec = parseXsdDecimalToBigIntScale(decInfo.lexStr);
-                    if (dec) {
-                        const scaledInt = intInfo.value * pow10n(dec.scale);
-                        if (scaledInt === dec.num)
-                            return { ...subst };
-                    }
+            else if (this.peek().typ === 'Ident' && (this.peek().value || '') === 'is') {
+                // N3 syntactic sugar: "S is P of O." means "O P S." (inverse; equivalent to "<-")
+                this.next(); // consume "is"
+                verb = this.parseTerm();
+                if (!(this.peek().typ === 'Ident' && (this.peek().value || '') === 'of')) {
+                    this.fail(`Expected 'of' after 'is <expr>', got ${this.peek().toString()}`);
                 }
+                this.next(); // consume "of"
+                invert = true;
+            }
+            else if (this.peek().typ === 'OpPredInvert') {
+                this.next(); // "<-"
+                verb = this.parseTerm();
+                invert = true;
+            }
+            else {
+                verb = this.parseTerm();
+            }
+            const objects = this.parseObjectList();
+            // If VERB or OBJECTS contained paths, their helper triples must come
+            // before the triples that consume the path results (Easter depends on this).
+            if (this.pendingTriples.length > 0) {
+                out.push(...this.pendingTriples);
+                this.pendingTriples = [];
+            }
+            for (const o of objects) {
+                out.push(new Triple(invert ? o : subject, verb, invert ? subject : o));
             }
+            if (this.peek().typ === 'Semicolon') {
+                this.next();
+                if (this.peek().typ === 'Dot')
+                    break;
+                continue;
+            }
+            break;
         }
+        return out;
     }
-    // Open list vs concrete list
-    if (a instanceof OpenListTerm && b instanceof ListTerm) {
-        return unifyOpenWithList(a.prefix, a.tailVar, b.elems, subst);
-    }
-    if (a instanceof ListTerm && b instanceof OpenListTerm) {
-        return unifyOpenWithList(b.prefix, b.tailVar, a.elems, subst);
-    }
-    // Open list vs open list
-    if (a instanceof OpenListTerm && b instanceof OpenListTerm) {
-        if (a.tailVar !== b.tailVar || a.prefix.length !== b.prefix.length)
-            return null;
-        let s2 = { ...subst };
-        for (let i = 0; i < a.prefix.length; i++) {
-            s2 = unifyTermWithOptions(a.prefix[i], b.prefix[i], s2, opts);
-            if (s2 === null)
-                return null;
+    parseObjectList() {
+        const objs = [this.parseTerm()];
+        while (this.peek().typ === 'Comma') {
+            this.next();
+            objs.push(this.parseTerm());
         }
-        return s2;
+        return objs;
     }
-    // List terms
-    if (a instanceof ListTerm && b instanceof ListTerm) {
-        if (a.elems.length !== b.elems.length)
-            return null;
-        let s2 = { ...subst };
-        for (let i = 0; i < a.elems.length; i++) {
-            s2 = unifyTermWithOptions(a.elems[i], b.elems[i], s2, opts);
-            if (s2 === null)
-                return null;
+    makeRule(left, right, isForward) {
+        let premiseTerm, conclTerm;
+        if (isForward) {
+            premiseTerm = left;
+            conclTerm = right;
         }
-        return s2;
-    }
-    // Graphs
-    if (a instanceof GraphTerm && b instanceof GraphTerm) {
-        if (alphaEqGraphTriples(a.triples, b.triples))
-            return { ...subst };
-        return unifyGraphTriples(a.triples, b.triples, subst);
-    }
-    return null;
-}
-function unifyTriple(pat, fact, subst) {
-    // Predicates are usually the cheapest and most selective
-    const s1 = unifyTerm(pat.p, fact.p, subst);
-    if (s1 === null)
-        return null;
-    const s2 = unifyTerm(pat.s, fact.s, s1);
-    if (s2 === null)
-        return null;
-    const s3 = unifyTerm(pat.o, fact.o, s2);
-    return s3;
-}
-function composeSubst(outer, delta) {
-    if (!delta || Object.keys(delta).length === 0) {
-        return { ...outer };
-    }
-    const out = { ...outer };
-    for (const [k, v] of Object.entries(delta)) {
-        if (out.hasOwnProperty(k)) {
-            if (!termsEqual(out[k], v))
-                return null;
+        else {
+            premiseTerm = right;
+            conclTerm = left;
+        }
+        let isFuse = false;
+        if (isForward) {
+            if (conclTerm instanceof Literal && conclTerm.value === 'false') {
+                isFuse = true;
+            }
+        }
+        let rawPremise;
+        if (premiseTerm instanceof GraphTerm) {
+            rawPremise = premiseTerm.triples;
+        }
+        else if (premiseTerm instanceof Literal && premiseTerm.value === 'true') {
+            rawPremise = [];
         }
         else {
-            out[k] = v;
+            rawPremise = [];
+        }
+        let rawConclusion;
+        if (conclTerm instanceof GraphTerm) {
+            rawConclusion = conclTerm.triples;
+        }
+        else if (conclTerm instanceof Literal && conclTerm.value === 'false') {
+            rawConclusion = [];
         }
+        else {
+            rawConclusion = [];
+        }
+        // Blank nodes that occur explicitly in the head (conclusion)
+        const headBlankLabels = collectBlankLabelsInTriples(rawConclusion);
+        const [premise0, conclusion] = liftBlankRuleVars(rawPremise, rawConclusion);
+        // Reorder constraints for *forward* rules.
+        const premise = isForward ? reorderPremiseForConstraints(premise0) : premise0;
+        return new Rule(premise, conclusion, isForward, isFuse, headBlankLabels);
     }
-    return out;
 }
+// @ts-nocheck
+/* eslint-disable */
 // ===========================================================================
 // BUILTINS
 // ===========================================================================
@@ -5916,20 +5593,119 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen, maxResults) {
     if (pv === STRING_NS + 'format') {
         if (!(g.s instanceof ListTerm) || g.s.elems.length < 1)
             return [];
-        const fmtStr = termToJsString(g.s.elems[0]);
-        if (fmtStr === null)
+        const fmtStr = termToJsString(g.s.elems[0]);
+        if (fmtStr === null)
+            return [];
+        const args = [];
+        for (let i = 1; i < g.s.elems.length; i++) {
+            const aStr = termToJsString(g.s.elems[i]);
+            if (aStr === null)
+                return [];
+            args.push(aStr);
+        }
+        const formatted = simpleStringFormat(fmtStr, args);
+        if (formatted === null)
+            return []; // unsupported format specifier(s)
+        const lit = makeStringLiteral(formatted);
+        if (g.o instanceof Var) {
+            const s2 = { ...subst };
+            s2[g.o.name] = lit;
+            return [s2];
+        }
+        const s2 = unifyTerm(g.o, lit, subst);
+        return s2 !== null ? [s2] : [];
+    }
+    // string:jsonPointer
+    // Schema: ( $jsonText $pointer ) string:jsonPointer $value
+    if (pv === STRING_NS + 'jsonPointer') {
+        if (!(g.s instanceof ListTerm) || g.s.elems.length !== 2)
+            return [];
+        const jsonText = termToJsonText(g.s.elems[0]);
+        const ptr = termToJsStringDecoded(g.s.elems[1]);
+        if (jsonText === null || ptr === null)
+            return [];
+        const valTerm = jsonPointerLookup(jsonText, ptr);
+        if (valTerm === null)
+            return [];
+        const s2 = unifyTerm(g.o, valTerm, subst);
+        return s2 !== null ? [s2] : [];
+    }
+    // string:greaterThan
+    if (pv === STRING_NS + 'greaterThan') {
+        const sStr = termToJsString(g.s);
+        const oStr = termToJsString(g.o);
+        if (sStr === null || oStr === null)
+            return [];
+        return sStr > oStr ? [{ ...subst }] : [];
+    }
+    // string:lessThan
+    if (pv === STRING_NS + 'lessThan') {
+        const sStr = termToJsString(g.s);
+        const oStr = termToJsString(g.o);
+        if (sStr === null || oStr === null)
+            return [];
+        return sStr < oStr ? [{ ...subst }] : [];
+    }
+    // string:matches
+    if (pv === STRING_NS + 'matches') {
+        const sStr = termToJsString(g.s);
+        const pattern = termToJsString(g.o);
+        if (sStr === null || pattern === null)
+            return [];
+        const re = compileSwapRegex(pattern, '');
+        if (!re)
+            return [];
+        return re.test(sStr) ? [{ ...subst }] : [];
+    }
+    // string:notEqualIgnoringCase
+    if (pv === STRING_NS + 'notEqualIgnoringCase') {
+        const sStr = termToJsString(g.s);
+        const oStr = termToJsString(g.o);
+        if (sStr === null || oStr === null)
+            return [];
+        return sStr.toLowerCase() !== oStr.toLowerCase() ? [{ ...subst }] : [];
+    }
+    // string:notGreaterThan  (≤ in Unicode code order)
+    if (pv === STRING_NS + 'notGreaterThan') {
+        const sStr = termToJsString(g.s);
+        const oStr = termToJsString(g.o);
+        if (sStr === null || oStr === null)
+            return [];
+        return sStr <= oStr ? [{ ...subst }] : [];
+    }
+    // string:notLessThan  (≥ in Unicode code order)
+    if (pv === STRING_NS + 'notLessThan') {
+        const sStr = termToJsString(g.s);
+        const oStr = termToJsString(g.o);
+        if (sStr === null || oStr === null)
+            return [];
+        return sStr >= oStr ? [{ ...subst }] : [];
+    }
+    // string:notMatches
+    if (pv === STRING_NS + 'notMatches') {
+        const sStr = termToJsString(g.s);
+        const pattern = termToJsString(g.o);
+        if (sStr === null || pattern === null)
+            return [];
+        const re = compileSwapRegex(pattern, '');
+        if (!re)
+            return [];
+        return re.test(sStr) ? [] : [{ ...subst }];
+    }
+    // string:replace
+    if (pv === STRING_NS + 'replace') {
+        if (!(g.s instanceof ListTerm) || g.s.elems.length !== 3)
+            return [];
+        const dataStr = termToJsString(g.s.elems[0]);
+        const searchStr = termToJsString(g.s.elems[1]);
+        const replStr = termToJsString(g.s.elems[2]);
+        if (dataStr === null || searchStr === null || replStr === null)
+            return [];
+        const re = compileSwapRegex(searchStr, 'g');
+        if (!re)
             return [];
-        const args = [];
-        for (let i = 1; i < g.s.elems.length; i++) {
-            const aStr = termToJsString(g.s.elems[i]);
-            if (aStr === null)
-                return [];
-            args.push(aStr);
-        }
-        const formatted = simpleStringFormat(fmtStr, args);
-        if (formatted === null)
-            return []; // unsupported format specifier(s)
-        const lit = makeStringLiteral(formatted);
+        const outStr = dataStr.replace(re, replStr);
+        const lit = makeStringLiteral(outStr);
         if (g.o instanceof Var) {
             const s2 = { ...subst };
             s2[g.o.name] = lit;
@@ -5938,161 +5714,392 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen, maxResults) {
         const s2 = unifyTerm(g.o, lit, subst);
         return s2 !== null ? [s2] : [];
     }
-    // string:jsonPointer
-    // Schema: ( $jsonText $pointer ) string:jsonPointer $value
-    if (pv === STRING_NS + 'jsonPointer') {
+    // string:scrape
+    if (pv === STRING_NS + 'scrape') {
         if (!(g.s instanceof ListTerm) || g.s.elems.length !== 2)
             return [];
-        const jsonText = termToJsonText(g.s.elems[0]);
-        const ptr = termToJsStringDecoded(g.s.elems[1]);
-        if (jsonText === null || ptr === null)
+        const dataStr = termToJsString(g.s.elems[0]);
+        const pattern = termToJsString(g.s.elems[1]);
+        if (dataStr === null || pattern === null)
             return [];
-        const valTerm = jsonPointerLookup(jsonText, ptr);
-        if (valTerm === null)
+        const re = compileSwapRegex(pattern, '');
+        if (!re)
             return [];
-        const s2 = unifyTerm(g.o, valTerm, subst);
+        const m = re.exec(dataStr);
+        // Spec says “exactly 1 group”; we just use the first capturing group if present.
+        if (!m || m.length < 2)
+            return [];
+        const group = m[1];
+        const lit = makeStringLiteral(group);
+        if (g.o instanceof Var) {
+            const s2 = { ...subst };
+            s2[g.o.name] = lit;
+            return [s2];
+        }
+        const s2 = unifyTerm(g.o, lit, subst);
         return s2 !== null ? [s2] : [];
     }
-    // string:greaterThan
-    if (pv === STRING_NS + 'greaterThan') {
+    // string:startsWith
+    if (pv === STRING_NS + 'startsWith') {
         const sStr = termToJsString(g.s);
         const oStr = termToJsString(g.o);
         if (sStr === null || oStr === null)
             return [];
-        return sStr > oStr ? [{ ...subst }] : [];
+        return sStr.startsWith(oStr) ? [{ ...subst }] : [];
+    }
+    // Unknown builtin
+    return [];
+}
+function isBuiltinPred(p) {
+    if (!(p instanceof Iri))
+        return false;
+    const v = p.value;
+    // Super restricted mode: only treat => / <= as builtins.
+    // Everything else should be handled as ordinary predicates (and thus must be
+    // provided explicitly as facts/rules, without builtin evaluation).
+    if (superRestrictedMode) {
+        return v === LOG_NS + 'implies' || v === LOG_NS + 'impliedBy';
+    }
+    // Treat RDF Collections as list-term builtins too.
+    if (v === RDF_NS + 'first' || v === RDF_NS + 'rest') {
+        return true;
+    }
+    return (v.startsWith(CRYPTO_NS) ||
+        v.startsWith(MATH_NS) ||
+        v.startsWith(LOG_NS) ||
+        v.startsWith(STRING_NS) ||
+        v.startsWith(TIME_NS) ||
+        v.startsWith(LIST_NS));
+}
+// @ts-nocheck
+/* eslint-disable */
+// ===========================================================================
+// Unification + substitution
+// ===========================================================================
+function containsVarTerm(t, v) {
+    if (t instanceof Var)
+        return t.name === v;
+    if (t instanceof ListTerm)
+        return t.elems.some((e) => containsVarTerm(e, v));
+    if (t instanceof OpenListTerm)
+        return t.prefix.some((e) => containsVarTerm(e, v)) || t.tailVar === v;
+    if (t instanceof GraphTerm)
+        return t.triples.some((tr) => containsVarTerm(tr.s, v) || containsVarTerm(tr.p, v) || containsVarTerm(tr.o, v));
+    return false;
+}
+function isGroundTermInGraph(t) {
+    // variables inside graph terms are treated as local placeholders,
+    // so they don't make the *surrounding triple* non-ground.
+    if (t instanceof OpenListTerm)
+        return false;
+    if (t instanceof ListTerm)
+        return t.elems.every((e) => isGroundTermInGraph(e));
+    if (t instanceof GraphTerm)
+        return t.triples.every((tr) => isGroundTripleInGraph(tr));
+    // Iri/Literal/Blank/Var are all OK inside formulas
+    return true;
+}
+function isGroundTripleInGraph(tr) {
+    return isGroundTermInGraph(tr.s) && isGroundTermInGraph(tr.p) && isGroundTermInGraph(tr.o);
+}
+function isGroundTerm(t) {
+    if (t instanceof Var)
+        return false;
+    if (t instanceof ListTerm)
+        return t.elems.every((e) => isGroundTerm(e));
+    if (t instanceof OpenListTerm)
+        return false;
+    if (t instanceof GraphTerm)
+        return t.triples.every((tr) => isGroundTripleInGraph(tr));
+    return true;
+}
+function isGroundTriple(tr) {
+    return isGroundTerm(tr.s) && isGroundTerm(tr.p) && isGroundTerm(tr.o);
+}
+// Canonical JSON-ish encoding for use as a Skolem cache key.
+// We only *call* this on ground terms in log:skolem, but it is
+// robust to seeing vars/open lists anyway.
+function skolemKeyFromTerm(t) {
+    function enc(u) {
+        if (u instanceof Iri)
+            return ['I', u.value];
+        if (u instanceof Literal)
+            return ['L', u.value];
+        if (u instanceof Blank)
+            return ['B', u.label];
+        if (u instanceof Var)
+            return ['V', u.name];
+        if (u instanceof ListTerm)
+            return ['List', u.elems.map(enc)];
+        if (u instanceof OpenListTerm)
+            return ['OpenList', u.prefix.map(enc), u.tailVar];
+        if (u instanceof GraphTerm)
+            return ['Graph', u.triples.map((tr) => [enc(tr.s), enc(tr.p), enc(tr.o)])];
+        return ['Other', String(u)];
+    }
+    return JSON.stringify(enc(t));
+}
+function applySubstTerm(t, s) {
+    // Common case: variable
+    if (t instanceof Var) {
+        // Fast path: unbound variable → no change
+        const first = s[t.name];
+        if (first === undefined) {
+            return t;
+        }
+        // Follow chains X -> Y -> ... until we hit a non-var or a cycle.
+        let cur = first;
+        const seen = new Set([t.name]);
+        while (cur instanceof Var) {
+            const name = cur.name;
+            if (seen.has(name))
+                break; // cycle
+            seen.add(name);
+            const nxt = s[name];
+            if (!nxt)
+                break;
+            cur = nxt;
+        }
+        if (cur instanceof Var) {
+            // Still a var: keep it as is (no need to clone)
+            return cur;
+        }
+        // Bound to a non-var term: apply substitution recursively in case it
+        // contains variables inside.
+        return applySubstTerm(cur, s);
+    }
+    // Non-variable terms
+    if (t instanceof ListTerm) {
+        return new ListTerm(t.elems.map((e) => applySubstTerm(e, s)));
+    }
+    if (t instanceof OpenListTerm) {
+        const newPrefix = t.prefix.map((e) => applySubstTerm(e, s));
+        const tailTerm = s[t.tailVar];
+        if (tailTerm !== undefined) {
+            const tailApplied = applySubstTerm(tailTerm, s);
+            if (tailApplied instanceof ListTerm) {
+                return new ListTerm(newPrefix.concat(tailApplied.elems));
+            }
+            else if (tailApplied instanceof OpenListTerm) {
+                return new OpenListTerm(newPrefix.concat(tailApplied.prefix), tailApplied.tailVar);
+            }
+            else {
+                return new OpenListTerm(newPrefix, t.tailVar);
+            }
+        }
+        else {
+            return new OpenListTerm(newPrefix, t.tailVar);
+        }
+    }
+    if (t instanceof GraphTerm) {
+        return new GraphTerm(t.triples.map((tr) => applySubstTriple(tr, s)));
+    }
+    return t;
+}
+function applySubstTriple(tr, s) {
+    return new Triple(applySubstTerm(tr.s, s), applySubstTerm(tr.p, s), applySubstTerm(tr.o, s));
+}
+function iriValue(t) {
+    return t instanceof Iri ? t.value : null;
+}
+function unifyOpenWithList(prefix, tailv, ys, subst) {
+    if (ys.length < prefix.length)
+        return null;
+    let s2 = { ...subst };
+    for (let i = 0; i < prefix.length; i++) {
+        s2 = unifyTerm(prefix[i], ys[i], s2);
+        if (s2 === null)
+            return null;
+    }
+    const rest = new ListTerm(ys.slice(prefix.length));
+    s2 = unifyTerm(new Var(tailv), rest, s2);
+    if (s2 === null)
+        return null;
+    return s2;
+}
+function unifyGraphTriples(xs, ys, subst) {
+    if (xs.length !== ys.length)
+        return null;
+    // Fast path: exact same sequence.
+    if (triplesListEqual(xs, ys))
+        return { ...subst };
+    // Backtracking match (order-insensitive), *threading* the substitution through.
+    const used = new Array(ys.length).fill(false);
+    function step(i, s) {
+        if (i >= xs.length)
+            return s;
+        const x = xs[i];
+        for (let j = 0; j < ys.length; j++) {
+            if (used[j])
+                continue;
+            const y = ys[j];
+            // Cheap pruning when both predicates are IRIs.
+            if (x.p instanceof Iri && y.p instanceof Iri && x.p.value !== y.p.value)
+                continue;
+            const s2 = unifyTriple(x, y, s); // IMPORTANT: use `s`, not {}
+            if (s2 === null)
+                continue;
+            used[j] = true;
+            const s3 = step(i + 1, s2);
+            if (s3 !== null)
+                return s3;
+            used[j] = false;
+        }
+        return null;
+    }
+    return step(0, { ...subst }); // IMPORTANT: start from the incoming subst
+}
+function unifyTerm(a, b, subst) {
+    return unifyTermWithOptions(a, b, subst, {
+        boolValueEq: true,
+        intDecimalEq: false,
+    });
+}
+function unifyTermListAppend(a, b, subst) {
+    // Keep list:append behavior: allow integer<->decimal exact equality,
+    // but do NOT add boolean-value equivalence (preserves current semantics).
+    return unifyTermWithOptions(a, b, subst, {
+        boolValueEq: false,
+        intDecimalEq: true,
+    });
+}
+function unifyTermWithOptions(a, b, subst, opts) {
+    a = applySubstTerm(a, subst);
+    b = applySubstTerm(b, subst);
+    // Variable binding
+    if (a instanceof Var) {
+        const v = a.name;
+        const t = b;
+        if (t instanceof Var && t.name === v)
+            return { ...subst };
+        if (containsVarTerm(t, v))
+            return null;
+        const s2 = { ...subst };
+        s2[v] = t;
+        return s2;
     }
-    // string:lessThan
-    if (pv === STRING_NS + 'lessThan') {
-        const sStr = termToJsString(g.s);
-        const oStr = termToJsString(g.o);
-        if (sStr === null || oStr === null)
-            return [];
-        return sStr < oStr ? [{ ...subst }] : [];
+    if (b instanceof Var) {
+        return unifyTermWithOptions(b, a, subst, opts);
     }
-    // string:matches
-    if (pv === STRING_NS + 'matches') {
-        const sStr = termToJsString(g.s);
-        const pattern = termToJsString(g.o);
-        if (sStr === null || pattern === null)
-            return [];
-        const re = compileSwapRegex(pattern, '');
-        if (!re)
-            return [];
-        return re.test(sStr) ? [{ ...subst }] : [];
+    // Exact matches
+    if (a instanceof Iri && b instanceof Iri && a.value === b.value)
+        return { ...subst };
+    if (a instanceof Literal && b instanceof Literal && a.value === b.value)
+        return { ...subst };
+    if (a instanceof Blank && b instanceof Blank && a.label === b.label)
+        return { ...subst };
+    // Plain string vs xsd:string equivalence
+    if (a instanceof Literal && b instanceof Literal) {
+        if (literalsEquivalentAsXsdString(a.value, b.value))
+            return { ...subst };
     }
-    // string:notEqualIgnoringCase
-    if (pv === STRING_NS + 'notEqualIgnoringCase') {
-        const sStr = termToJsString(g.s);
-        const oStr = termToJsString(g.o);
-        if (sStr === null || oStr === null)
-            return [];
-        return sStr.toLowerCase() !== oStr.toLowerCase() ? [{ ...subst }] : [];
+    // Boolean-value equivalence (ONLY for normal unifyTerm)
+    if (opts.boolValueEq && a instanceof Literal && b instanceof Literal) {
+        const ai = parseBooleanLiteralInfo(a);
+        const bi = parseBooleanLiteralInfo(b);
+        if (ai && bi && ai.value === bi.value)
+            return { ...subst };
     }
-    // string:notGreaterThan  (≤ in Unicode code order)
-    if (pv === STRING_NS + 'notGreaterThan') {
-        const sStr = termToJsString(g.s);
-        const oStr = termToJsString(g.o);
-        if (sStr === null || oStr === null)
-            return [];
-        return sStr <= oStr ? [{ ...subst }] : [];
+    // Numeric-value match:
+    // - always allow equality when datatype matches (existing behavior)
+    // - optionally allow integer<->decimal exact equality (list:append only)
+    if (a instanceof Literal && b instanceof Literal) {
+        const ai = parseNumericLiteralInfo(a);
+        const bi = parseNumericLiteralInfo(b);
+        if (ai && bi) {
+            if (ai.dt === bi.dt) {
+                if (ai.kind === 'bigint' && bi.kind === 'bigint') {
+                    if (ai.value === bi.value)
+                        return { ...subst };
+                }
+                else {
+                    const an = ai.kind === 'bigint' ? Number(ai.value) : ai.value;
+                    const bn = bi.kind === 'bigint' ? Number(bi.value) : bi.value;
+                    if (!Number.isNaN(an) && !Number.isNaN(bn) && an === bn)
+                        return { ...subst };
+                }
+            }
+            if (opts.intDecimalEq) {
+                const intDt = XSD_NS + 'integer';
+                const decDt = XSD_NS + 'decimal';
+                if ((ai.dt === intDt && bi.dt === decDt) || (ai.dt === decDt && bi.dt === intDt)) {
+                    const intInfo = ai.dt === intDt ? ai : bi; // bigint
+                    const decInfo = ai.dt === decDt ? ai : bi; // number + lexStr
+                    const dec = parseXsdDecimalToBigIntScale(decInfo.lexStr);
+                    if (dec) {
+                        const scaledInt = intInfo.value * pow10n(dec.scale);
+                        if (scaledInt === dec.num)
+                            return { ...subst };
+                    }
+                }
+            }
+        }
     }
-    // string:notLessThan  (≥ in Unicode code order)
-    if (pv === STRING_NS + 'notLessThan') {
-        const sStr = termToJsString(g.s);
-        const oStr = termToJsString(g.o);
-        if (sStr === null || oStr === null)
-            return [];
-        return sStr >= oStr ? [{ ...subst }] : [];
+    // Open list vs concrete list
+    if (a instanceof OpenListTerm && b instanceof ListTerm) {
+        return unifyOpenWithList(a.prefix, a.tailVar, b.elems, subst);
     }
-    // string:notMatches
-    if (pv === STRING_NS + 'notMatches') {
-        const sStr = termToJsString(g.s);
-        const pattern = termToJsString(g.o);
-        if (sStr === null || pattern === null)
-            return [];
-        const re = compileSwapRegex(pattern, '');
-        if (!re)
-            return [];
-        return re.test(sStr) ? [] : [{ ...subst }];
+    if (a instanceof ListTerm && b instanceof OpenListTerm) {
+        return unifyOpenWithList(b.prefix, b.tailVar, a.elems, subst);
     }
-    // string:replace
-    if (pv === STRING_NS + 'replace') {
-        if (!(g.s instanceof ListTerm) || g.s.elems.length !== 3)
-            return [];
-        const dataStr = termToJsString(g.s.elems[0]);
-        const searchStr = termToJsString(g.s.elems[1]);
-        const replStr = termToJsString(g.s.elems[2]);
-        if (dataStr === null || searchStr === null || replStr === null)
-            return [];
-        const re = compileSwapRegex(searchStr, 'g');
-        if (!re)
-            return [];
-        const outStr = dataStr.replace(re, replStr);
-        const lit = makeStringLiteral(outStr);
-        if (g.o instanceof Var) {
-            const s2 = { ...subst };
-            s2[g.o.name] = lit;
-            return [s2];
+    // Open list vs open list
+    if (a instanceof OpenListTerm && b instanceof OpenListTerm) {
+        if (a.tailVar !== b.tailVar || a.prefix.length !== b.prefix.length)
+            return null;
+        let s2 = { ...subst };
+        for (let i = 0; i < a.prefix.length; i++) {
+            s2 = unifyTermWithOptions(a.prefix[i], b.prefix[i], s2, opts);
+            if (s2 === null)
+                return null;
         }
-        const s2 = unifyTerm(g.o, lit, subst);
-        return s2 !== null ? [s2] : [];
+        return s2;
     }
-    // string:scrape
-    if (pv === STRING_NS + 'scrape') {
-        if (!(g.s instanceof ListTerm) || g.s.elems.length !== 2)
-            return [];
-        const dataStr = termToJsString(g.s.elems[0]);
-        const pattern = termToJsString(g.s.elems[1]);
-        if (dataStr === null || pattern === null)
-            return [];
-        const re = compileSwapRegex(pattern, '');
-        if (!re)
-            return [];
-        const m = re.exec(dataStr);
-        // Spec says “exactly 1 group”; we just use the first capturing group if present.
-        if (!m || m.length < 2)
-            return [];
-        const group = m[1];
-        const lit = makeStringLiteral(group);
-        if (g.o instanceof Var) {
-            const s2 = { ...subst };
-            s2[g.o.name] = lit;
-            return [s2];
+    // List terms
+    if (a instanceof ListTerm && b instanceof ListTerm) {
+        if (a.elems.length !== b.elems.length)
+            return null;
+        let s2 = { ...subst };
+        for (let i = 0; i < a.elems.length; i++) {
+            s2 = unifyTermWithOptions(a.elems[i], b.elems[i], s2, opts);
+            if (s2 === null)
+                return null;
         }
-        const s2 = unifyTerm(g.o, lit, subst);
-        return s2 !== null ? [s2] : [];
+        return s2;
     }
-    // string:startsWith
-    if (pv === STRING_NS + 'startsWith') {
-        const sStr = termToJsString(g.s);
-        const oStr = termToJsString(g.o);
-        if (sStr === null || oStr === null)
-            return [];
-        return sStr.startsWith(oStr) ? [{ ...subst }] : [];
+    // Graphs
+    if (a instanceof GraphTerm && b instanceof GraphTerm) {
+        if (alphaEqGraphTriples(a.triples, b.triples))
+            return { ...subst };
+        return unifyGraphTriples(a.triples, b.triples, subst);
     }
-    // Unknown builtin
-    return [];
+    return null;
 }
-function isBuiltinPred(p) {
-    if (!(p instanceof Iri))
-        return false;
-    const v = p.value;
-    // Super restricted mode: only treat => / <= as builtins.
-    // Everything else should be handled as ordinary predicates (and thus must be
-    // provided explicitly as facts/rules, without builtin evaluation).
-    if (superRestrictedMode) {
-        return v === LOG_NS + 'implies' || v === LOG_NS + 'impliedBy';
+function unifyTriple(pat, fact, subst) {
+    // Predicates are usually the cheapest and most selective
+    const s1 = unifyTerm(pat.p, fact.p, subst);
+    if (s1 === null)
+        return null;
+    const s2 = unifyTerm(pat.s, fact.s, s1);
+    if (s2 === null)
+        return null;
+    const s3 = unifyTerm(pat.o, fact.o, s2);
+    return s3;
+}
+function composeSubst(outer, delta) {
+    if (!delta || Object.keys(delta).length === 0) {
+        return { ...outer };
     }
-    // Treat RDF Collections as list-term builtins too.
-    if (v === RDF_NS + 'first' || v === RDF_NS + 'rest') {
-        return true;
+    const out = { ...outer };
+    for (const [k, v] of Object.entries(delta)) {
+        if (out.hasOwnProperty(k)) {
+            if (!termsEqual(out[k], v))
+                return null;
+        }
+        else {
+            out[k] = v;
+        }
     }
-    return (v.startsWith(CRYPTO_NS) ||
-        v.startsWith(MATH_NS) ||
-        v.startsWith(LOG_NS) ||
-        v.startsWith(STRING_NS) ||
-        v.startsWith(TIME_NS) ||
-        v.startsWith(LIST_NS));
+    return out;
 }
 // ===========================================================================
 // Backward proof (SLD-style)