@undefineds.co/xpod 0.3.5 → 0.3.14

package/dist/storage/rdf/RdfSparqlAdapter.js

@@ -0,0 +1,2420 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RdfSparqlAdapter = exports.DisabledSparqlFeatureError = exports.UnsupportedSparqlQueryError = void 0;
+const n3_1 = require("n3");
+const sparqljs_1 = require("sparqljs");
+const RdfLocalQueryEngine_1 = require("./RdfLocalQueryEngine");
+const PATH_JOIN_VARIABLE_PREFIX = '__rdf_path';
+const XPATH_FUNCTION_NS = 'http://www.w3.org/2005/xpath-functions#';
+class UnsupportedSparqlQueryError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'UnsupportedSparqlQueryError';
+    }
+}
+exports.UnsupportedSparqlQueryError = UnsupportedSparqlQueryError;
+class DisabledSparqlFeatureError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'DisabledSparqlFeatureError';
+    }
+}
+exports.DisabledSparqlFeatureError = DisabledSparqlFeatureError;
+class RdfSparqlAdapter {
+    compile(query, basePath) {
+        const parsed = typeof query === 'string'
+            ? new sparqljs_1.Parser({ baseIRI: basePath }).parse(query)
+            : query;
+        if (parsed.type === 'update') {
+            throw new UnsupportedSparqlQueryError('SPARQL UPDATE is handled by the compatibility engine');
+        }
+        const datasetScope = this.compileQueryDatasetScope(this.queryFromClause(parsed), basePath);
+        const state = new CompileState(basePath);
+        this.compilePatterns(parsed.where ?? [], datasetScope.defaultGraph, state, false, datasetScope.namedGraph);
+        this.compileValuesRows(parsed.values ?? [], state);
+        this.compileGroupBy(parsed.group ?? [], state);
+        if (parsed.queryType === 'SELECT') {
+            state.query.orderBy = this.compileOrder(parsed.order ?? [], state);
+        }
+        const variables = parsed.queryType === 'SELECT'
+            ? this.compileSelectVariables(parsed, state)
+            : [];
+        if (parsed.queryType === 'SELECT') {
+            state.query.having = this.compileHaving(parsed.having ?? [], state);
+        }
+        state.assertBindVariablesSafe();
+        state.assertValuesVariablesBoundByRequiredPatterns();
+        state.assertDependentGroupsShareRequiredVariables();
+        const constructTemplate = parsed.queryType === 'CONSTRUCT'
+            ? this.compileConstructTemplate(parsed)
+            : undefined;
+        const describeTargets = parsed.queryType === 'DESCRIBE'
+            ? this.compileDescribeTargets(parsed, state.query)
+            : undefined;
+        if (parsed.queryType === 'ASK') {
+            state.query.limit = 1;
+        }
+        else if (parsed.queryType === 'SELECT') {
+            state.query.select = variables.length > 0 ? variables : undefined;
+            state.query.distinct = Boolean(parsed.distinct);
+            state.query.limit = parsed.limit;
+            state.query.offset = parsed.offset;
+        }
+        return {
+            query: state.query,
+            variables,
+            queryType: parsed.queryType,
+            constructTemplate,
+            describeTargets,
+        };
+    }
+    compileUpdateDelta(query, basePath) {
+        const parsed = typeof query === 'string'
+            ? new sparqljs_1.Parser({ baseIRI: basePath }).parse(query)
+            : query;
+        if (parsed.type !== 'update') {
+            throw new UnsupportedSparqlQueryError('Only SPARQL UPDATE can compile into update delta');
+        }
+        const operations = [];
+        for (const update of parsed.updates) {
+            if (!('updateType' in update)) {
+                throw new UnsupportedSparqlQueryError('SPARQL UPDATE management operations fallback to compatibility engine');
+            }
+            switch (update.updateType) {
+                case 'insert':
+                    if (update.graph) {
+                        throw new UnsupportedSparqlQueryError('SPARQL UPDATE WITH/default graph scope fallback to compatibility engine');
+                    }
+                    operations.push({
+                        type: 'insert',
+                        quads: this.compileUpdateGraphQuads(update.insert, basePath),
+                    });
+                    break;
+                case 'delete':
+                    if (update.graph) {
+                        throw new UnsupportedSparqlQueryError('SPARQL UPDATE WITH/default graph scope fallback to compatibility engine');
+                    }
+                    operations.push({
+                        type: 'delete',
+                        quads: this.compileUpdateGraphQuads(update.delete, basePath),
+                    });
+                    break;
+                case 'deletewhere':
+                    if (update.graph) {
+                        throw new UnsupportedSparqlQueryError('SPARQL UPDATE WITH/default graph scope fallback to compatibility engine');
+                    }
+                    operations.push(this.compileDeleteWhere(update.delete, basePath));
+                    break;
+                case 'insertdelete':
+                    operations.push(this.compileInsertDeleteWhere(update, basePath));
+                    break;
+                default:
+                    throw new UnsupportedSparqlQueryError('Unsupported SPARQL UPDATE operation fallback to compatibility engine');
+            }
+        }
+        const inserts = operations
+            .filter((operation) => operation.type === 'insert')
+            .flatMap((operation) => operation.quads);
+        const deletes = operations
+            .filter((operation) => operation.type === 'delete')
+            .flatMap((operation) => operation.quads);
+        const deleteWhereCount = operations
+            .reduce((sum, operation) => {
+            if (operation.type === 'deleteWhere') {
+                return sum + operation.template.length;
+            }
+            if (operation.type === 'insertDeleteWhere') {
+                return sum + operation.deletes.length + operation.inserts.length;
+            }
+            if (operation.type === 'insertWhere') {
+                return sum + operation.inserts.length;
+            }
+            return sum;
+        }, 0);
+        if (inserts.length + deletes.length + deleteWhereCount === 0) {
+            throw new UnsupportedSparqlQueryError('SPARQL UPDATE without data quads fallback to compatibility engine');
+        }
+        return { operations, inserts, deletes };
+    }
+    compileDeleteWhere(items, basePath) {
+        const template = this.compileGraphQuadsTemplate(items, basePath, 'DELETE WHERE');
+        return {
+            type: 'deleteWhere',
+            query: this.queryFromUpdateTemplate(template, 'DELETE WHERE'),
+            template,
+        };
+    }
+    compileInsertDeleteWhere(update, basePath) {
+        const hasInsertTemplate = (update.insert?.length ?? 0) > 0;
+        const hasDeleteTemplate = (update.delete?.length ?? 0) > 0;
+        if (!hasInsertTemplate && !hasDeleteTemplate) {
+            throw new UnsupportedSparqlQueryError('DELETE/INSERT WHERE without DELETE or INSERT template fallback to compatibility engine');
+        }
+        const label = hasInsertTemplate && hasDeleteTemplate
+            ? 'DELETE/INSERT WHERE'
+            : hasInsertTemplate
+                ? 'INSERT WHERE'
+                : 'DELETE WHERE';
+        const withGraph = this.compileWithGraph(update.graph, basePath, label);
+        const using = this.compileUsingDatasetScope(update.using, basePath, label);
+        const queryDefaultGraph = using.hasUsing
+            ? using.defaultGraph ?? this.impossibleGraph(basePath)
+            : withGraph;
+        const queryNamedGraph = using.hasUsing
+            ? using.namedGraph ?? this.impossibleGraph(basePath)
+            : undefined;
+        const query = this.queryFromUpdateWhere(update.where ?? [], basePath, label, {
+            defaultGraph: queryDefaultGraph,
+            namedGraph: queryNamedGraph,
+        });
+        const inserts = hasInsertTemplate
+            ? this.compileGraphQuadsTemplate(update.insert ?? [], basePath, 'INSERT template', withGraph)
+            : [];
+        if (hasInsertTemplate && inserts.length === 0) {
+            throw new UnsupportedSparqlQueryError(`${label} without INSERT template fallback to compatibility engine`);
+        }
+        const deletes = hasDeleteTemplate
+            ? this.compileGraphQuadsTemplate(update.delete ?? [], basePath, 'DELETE template', withGraph)
+            : [];
+        if (hasDeleteTemplate && deletes.length === 0) {
+            throw new UnsupportedSparqlQueryError(`${label} without DELETE template fallback to compatibility engine`);
+        }
+        if (hasInsertTemplate && !hasDeleteTemplate) {
+            return {
+                type: 'insertWhere',
+                query,
+                inserts,
+            };
+        }
+        if (!hasInsertTemplate) {
+            return {
+                type: 'deleteWhere',
+                query,
+                template: deletes,
+            };
+        }
+        return {
+            type: 'insertDeleteWhere',
+            query,
+            deletes,
+            inserts,
+        };
+    }
+    compileUsingDatasetScope(using, basePath, label) {
+        if (!using) {
+            return { hasUsing: false };
+        }
+        const defaultGraphs = using.default ?? [];
+        const namedGraphs = using.named ?? [];
+        return {
+            hasUsing: true,
+            defaultGraph: this.compileUsingGraphs(defaultGraphs, basePath, label, 'USING'),
+            namedGraph: this.compileUsingGraphs(namedGraphs, basePath, label, 'USING NAMED'),
+        };
+    }
+    compileUsingGraphs(graphs, basePath, label, clause) {
+        if (graphs.length === 0) {
+            return undefined;
+        }
+        const compiledGraphs = graphs.map((graph) => {
+            const compiled = this.compileGraphTerm(graph, basePath);
+            if (compiled === null || isCompiledVariable(compiled)) {
+                throw new UnsupportedSparqlQueryError(`${label} ${clause} graph outside basePath fallback to compatibility engine`);
+            }
+            return compiled;
+        });
+        if (compiledGraphs.length === 1) {
+            return compiledGraphs[0];
+        }
+        return { $in: uniqueTerms(compiledGraphs) };
+    }
+    compileQueryDatasetScope(from, basePath) {
+        if (!from) {
+            return {};
+        }
+        const defaultGraphs = from.default ?? [];
+        const namedGraphs = from.named ?? [];
+        return {
+            defaultGraph: defaultGraphs.length > 0
+                ? this.compileQueryDatasetGraphs(defaultGraphs, basePath, 'FROM')
+                : namedGraphs.length > 0
+                    ? this.impossibleGraph(basePath)
+                    : undefined,
+            namedGraph: namedGraphs.length > 0
+                ? this.compileQueryDatasetGraphs(namedGraphs, basePath, 'FROM NAMED')
+                : undefined,
+        };
+    }
+    compileQueryDatasetGraphs(graphs, basePath, clause) {
+        const compiledGraphs = graphs.map((graph) => {
+            const compiled = this.compileGraphTerm(graph, basePath);
+            if (compiled === null || isCompiledVariable(compiled)) {
+                throw new DisabledSparqlFeatureError(`SPARQL ${clause} outside the server-owned Pod is disabled`);
+            }
+            return compiled;
+        });
+        if (compiledGraphs.length === 1) {
+            return compiledGraphs[0];
+        }
+        return { $in: uniqueTerms(compiledGraphs) };
+    }
+    queryFromClause(query) {
+        if (!('from' in query)) {
+            return undefined;
+        }
+        return query.from;
+    }
+    compileWithGraph(graph, basePath, label) {
+        if (!graph) {
+            return undefined;
+        }
+        const compiled = this.compileGraphTerm(graph, basePath);
+        if (compiled === null || isCompiledVariable(compiled)) {
+            throw new UnsupportedSparqlQueryError(`${label} WITH graph outside basePath fallback to compatibility engine`);
+        }
+        return compiled;
+    }
+    impossibleGraph(basePath) {
+        return n3_1.DataFactory.namedNode(`${basePath}__outside_graph_scope__`);
+    }
+    queryFromUpdateWhere(patterns, basePath, label, dataset = {}) {
+        if (patterns.length === 0) {
+            throw new UnsupportedSparqlQueryError(`${label} without WHERE patterns fallback to compatibility engine`);
+        }
+        const state = new CompileState(basePath);
+        this.assertScopedUpdateWherePatterns(patterns, basePath, label, Boolean(dataset.defaultGraph), dataset.namedGraph);
+        this.compilePatterns(patterns, dataset.defaultGraph, state, false, dataset.namedGraph);
+        state.assertBindVariablesSafe();
+        state.assertValuesVariablesBoundByRequiredPatterns();
+        state.assertDependentGroupsShareRequiredVariables();
+        if (state.query.patterns.length === 0 && (state.query.unions?.length ?? 0) === 0) {
+            throw new UnsupportedSparqlQueryError(`${label} without required graph BGP patterns fallback to compatibility engine`);
+        }
+        return state.query;
+    }
+    queryFromUpdateTemplate(template, label) {
+        if (template.length === 0) {
+            throw new UnsupportedSparqlQueryError(`${label} without WHERE patterns fallback to compatibility engine`);
+        }
+        return {
+            patterns: template.map((pattern) => ({
+                graph: pattern.graph,
+                subject: pattern.subject,
+                predicate: pattern.predicate,
+                object: pattern.object,
+            })),
+            optional: [],
+            filters: [],
+        };
+    }
+    compileGraphQuadsTemplate(items, basePath, label, defaultGraph) {
+        const template = [];
+        for (const item of items) {
+            let graph = defaultGraph;
+            if (item.type === 'graph') {
+                if (item.name.termType !== 'NamedNode') {
+                    throw new UnsupportedSparqlQueryError(`${label} GRAPH variables fallback to compatibility engine`);
+                }
+                graph = this.compileGraphTerm(item.name, basePath) ?? undefined;
+            }
+            else if (!graph) {
+                throw new UnsupportedSparqlQueryError(`${label} default graph fallback to compatibility engine`);
+            }
+            if (!graph || graph === null || isCompiledVariable(graph)) {
+                throw new UnsupportedSparqlQueryError(`${label} graph outside basePath fallback to compatibility engine`);
+            }
+            const state = new CompileState(basePath);
+            for (const triple of item.triples) {
+                if (!isSimpleTerm(triple.predicate)) {
+                    throw new UnsupportedSparqlQueryError(`${label} property path templates fallback to compatibility engine`);
+                }
+                const patterns = this.compileTriple(triple, graph, state);
+                if (patterns.length !== 1) {
+                    throw new UnsupportedSparqlQueryError(`${label} property path templates fallback to compatibility engine`);
+                }
+                const pattern = patterns[0];
+                this.assertSafeUpdateTemplatePattern(pattern, label);
+                template.push({
+                    graph,
+                    subject: pattern.subject,
+                    predicate: pattern.predicate,
+                    object: pattern.object,
+                });
+            }
+        }
+        return template;
+    }
+    assertSafeUpdateTemplatePattern(pattern, label) {
+        const terms = [pattern.subject, pattern.predicate, pattern.object];
+        if (terms.some((term) => term && 'termType' in term && term.termType === 'BlankNode')) {
+            throw new UnsupportedSparqlQueryError(`${label} blank node templates fallback to compatibility engine`);
+        }
+    }
+    assertScopedUpdateWherePatterns(patterns, basePath, label, inGraph, namedGraph) {
+        if (patterns.length === 0) {
+            throw new UnsupportedSparqlQueryError(`${label} without WHERE patterns fallback to compatibility engine`);
+        }
+        for (const pattern of patterns) {
+            switch (pattern.type) {
+                case 'graph':
+                    if (pattern.name.termType === 'Variable') {
+                        if (!namedGraph) {
+                            throw new UnsupportedSparqlQueryError(`${label} GRAPH variables fallback to compatibility engine`);
+                        }
+                    }
+                    else if (pattern.name.termType !== 'NamedNode') {
+                        throw new UnsupportedSparqlQueryError(`${label} GRAPH variables fallback to compatibility engine`);
+                    }
+                    else if (!pattern.name.value.startsWith(basePath)) {
+                        throw new UnsupportedSparqlQueryError(`${label} graph outside basePath fallback to compatibility engine`);
+                    }
+                    this.assertScopedUpdateWherePatterns(pattern.patterns, basePath, label, true, namedGraph);
+                    break;
+                case 'bgp':
+                    if (!inGraph) {
+                        throw new UnsupportedSparqlQueryError(`${label} default graph fallback to compatibility engine`);
+                    }
+                    break;
+                case 'optional':
+                case 'group':
+                    this.assertScopedUpdateWherePatterns(pattern.patterns, basePath, label, inGraph, namedGraph);
+                    break;
+                case 'union':
+                    for (const branch of pattern.patterns) {
+                        this.assertScopedUpdateWherePatterns(this.unionBranchPatterns(branch), basePath, label, inGraph, namedGraph);
+                    }
+                    break;
+                case 'filter':
+                case 'values':
+                    break;
+                default:
+                    if ('queryType' in pattern) {
+                        throw new UnsupportedSparqlQueryError(`${label} subqueries fallback to compatibility engine`);
+                    }
+                    break;
+            }
+        }
+    }
+    compileUpdateGraphQuads(items, basePath) {
+        const quads = [];
+        for (const item of items) {
+            if (item.type !== 'graph') {
+                throw new UnsupportedSparqlQueryError('SPARQL UPDATE default graph fallback to compatibility engine');
+            }
+            if (item.name.termType !== 'NamedNode') {
+                throw new UnsupportedSparqlQueryError('SPARQL UPDATE GRAPH variables fallback to compatibility engine');
+            }
+            if (!item.name.value.startsWith(basePath)) {
+                throw new UnsupportedSparqlQueryError('SPARQL UPDATE graph outside basePath fallback to compatibility engine');
+            }
+            for (const triple of item.triples) {
+                quads.push(this.compileUpdateTriple(triple, item.name));
+            }
+        }
+        return quads;
+    }
+    compileUpdateTriple(triple, graph) {
+        const subject = this.compileUpdateNamedNode(triple.subject, 'subject');
+        const predicate = this.compileUpdateNamedNode(triple.predicate, 'predicate');
+        const object = this.compileUpdateObject(triple.object);
+        return n3_1.DataFactory.quad(subject, predicate, object, graph);
+    }
+    compileUpdateNamedNode(term, position) {
+        if (isNamedNodeTerm(term)) {
+            return term;
+        }
+        throw new UnsupportedSparqlQueryError(`SPARQL UPDATE ${position} must be a named node in embedded delta path`);
+    }
+    compileUpdateObject(term) {
+        if (isNamedNodeTerm(term) || isLiteralTerm(term)) {
+            return term;
+        }
+        throw new UnsupportedSparqlQueryError('SPARQL UPDATE object must be a named node or literal in embedded delta path');
+    }
+    compilePatterns(patterns, graph, state, optional, namedGraphScope) {
+        for (const pattern of patterns) {
+            switch (pattern.type) {
+                case 'bgp':
+                    this.compileBgp(pattern, graph, state, optional);
+                    break;
+                case 'graph':
+                    this.compileGraphPattern(pattern, state, optional, namedGraphScope);
+                    break;
+                case 'optional':
+                    state.startOptional();
+                    this.compilePatterns(pattern.patterns, graph, state, true, namedGraphScope);
+                    state.finishOptional();
+                    break;
+                case 'filter': {
+                    const expression = pattern.expression;
+                    const notExistsPatterns = this.notExistsPatterns(expression);
+                    if (notExistsPatterns) {
+                        if (optional) {
+                            state.addOptionalMinus(this.compileAntiJoinGroup(notExistsPatterns, graph, state.basePath, 'FILTER NOT EXISTS', namedGraphScope));
+                            break;
+                        }
+                        state.addMinus(this.compileAntiJoinGroup(notExistsPatterns, graph, state.basePath, 'FILTER NOT EXISTS', namedGraphScope));
+                        break;
+                    }
+                    const existsPatterns = this.existsPatterns(expression);
+                    if (existsPatterns) {
+                        if (optional) {
+                            state.addOptionalExists(this.compileExistsGroup(existsPatterns, graph, state.basePath, 'FILTER EXISTS', namedGraphScope));
+                            break;
+                        }
+                        state.addExists(this.compileExistsGroup(existsPatterns, graph, state.basePath, 'FILTER EXISTS', namedGraphScope));
+                        break;
+                    }
+                    if (optional) {
+                        state.addOptionalFilters(this.compileFilter(expression));
+                        break;
+                    }
+                    state.query.filters?.push(...this.compileFilter(expression));
+                    break;
+                }
+                case 'group':
+                    this.compilePatterns(pattern.patterns, graph, state, optional, namedGraphScope);
+                    break;
+                case 'union':
+                    if (optional) {
+                        state.addOptionalUnion(this.compileUnionBranches(pattern.patterns, graph, state.basePath, namedGraphScope));
+                        break;
+                    }
+                    state.addUnion(this.compileUnionBranches(pattern.patterns, graph, state.basePath, namedGraphScope));
+                    break;
+                case 'service':
+                    throw new DisabledSparqlFeatureError('SPARQL SERVICE federation is disabled for server-owned Pod queries');
+                case 'bind':
+                    state.addBind(this.compileBind(pattern, state.basePath), optional);
+                    break;
+                case 'minus':
+                    if (optional) {
+                        state.addOptionalMinus(this.compileMinusGroup(pattern, graph, state.basePath, namedGraphScope));
+                        break;
+                    }
+                    state.addMinus(this.compileMinusGroup(pattern, graph, state.basePath, namedGraphScope));
+                    break;
+                case 'values':
+                    this.compileValuesRows(pattern.values, state, optional);
+                    break;
+                default:
+                    if ('queryType' in pattern) {
+                        throw new UnsupportedSparqlQueryError('Subqueries fallback to compatibility engine');
+                    }
+                    throw new UnsupportedSparqlQueryError(`Unsupported SPARQL pattern: ${pattern.type ?? 'unknown'}`);
+            }
+        }
+    }
+    compileUnionBranches(branches, graph, basePath, namedGraphScope) {
+        if (branches.length < 2) {
+            throw new UnsupportedSparqlQueryError('UNION requires at least two branches locally');
+        }
+        const compiledBranches = [];
+        for (const branch of branches) {
+            compiledBranches.push(...this.compileUnionBranch(branch, graph, basePath, namedGraphScope));
+        }
+        return compiledBranches;
+    }
+    compileUnionBranch(branch, graph, basePath, namedGraphScope) {
+        if (branch.type === 'union') {
+            return branch.patterns.flatMap((nestedBranch) => (this.compileUnionBranch(nestedBranch, graph, basePath, namedGraphScope)));
+        }
+        const branchState = new CompileState(basePath);
+        this.compilePatterns(this.unionBranchPatterns(branch), graph, branchState, false, namedGraphScope);
+        branchState.assertBindVariablesSafe();
+        branchState.assertValuesVariablesBoundByRequiredPatterns();
+        if (branchState.query.unions?.length) {
+            throw new UnsupportedSparqlQueryError('Nested UNION fallback to compatibility engine');
+        }
+        if (branchState.query.patterns.length === 0) {
+            throw new UnsupportedSparqlQueryError('UNION branch without required BGP fallback to compatibility engine');
+        }
+        return [{
+                patterns: branchState.query.patterns,
+                ...(branchState.query.values?.length ? { values: branchState.query.values } : {}),
+                ...(branchState.query.optional?.length ? { optional: branchState.query.optional } : {}),
+                ...(branchState.query.binds?.length ? { binds: branchState.query.binds } : {}),
+                ...(branchState.query.filters?.length ? { filters: branchState.query.filters } : {}),
+            }];
+    }
+    compileMinusGroup(pattern, graph, basePath, namedGraphScope) {
+        return this.compileAntiJoinGroup(pattern.patterns, graph, basePath, 'MINUS', namedGraphScope);
+    }
+    compileAntiJoinGroup(patterns, graph, basePath, label, namedGraphScope) {
+        const minusState = new CompileState(basePath, true);
+        this.compilePatterns(patterns, graph, minusState, false, namedGraphScope);
+        minusState.assertBindVariablesSafe();
+        minusState.assertValuesVariablesBoundByRequiredPatterns();
+        if (minusState.query.minus?.length || minusState.query.exists?.length) {
+            throw new UnsupportedSparqlQueryError(`Nested ${label} fallback to compatibility engine`);
+        }
+        if (minusState.query.patterns.length === 0 && (minusState.query.unions?.length ?? 0) === 0) {
+            throw new UnsupportedSparqlQueryError(`${label} without required BGP fallback to compatibility engine`);
+        }
+        return {
+            patterns: minusState.query.patterns,
+            ...(minusState.query.values?.length ? { values: minusState.query.values } : {}),
+            ...(minusState.query.unions?.length ? { unions: minusState.query.unions } : {}),
+            ...(minusState.query.optional?.length ? { optional: minusState.query.optional } : {}),
+            ...(minusState.query.binds?.length ? { binds: minusState.query.binds } : {}),
+            ...(minusState.query.filters?.length ? { filters: minusState.query.filters } : {}),
+        };
+    }
+    compileExistsGroup(patterns, graph, basePath, label, namedGraphScope) {
+        const existsState = new CompileState(basePath, true);
+        this.compilePatterns(patterns, graph, existsState, false, namedGraphScope);
+        existsState.assertBindVariablesSafe();
+        existsState.assertValuesVariablesBoundByRequiredPatterns();
+        if (existsState.query.minus?.length || existsState.query.exists?.length) {
+            throw new UnsupportedSparqlQueryError(`Nested ${label} fallback to compatibility engine`);
+        }
+        if (existsState.query.patterns.length === 0 && (existsState.query.unions?.length ?? 0) === 0) {
+            throw new UnsupportedSparqlQueryError(`${label} without required BGP fallback to compatibility engine`);
+        }
+        return {
+            patterns: existsState.query.patterns,
+            ...(existsState.query.values?.length ? { values: existsState.query.values } : {}),
+            ...(existsState.query.unions?.length ? { unions: existsState.query.unions } : {}),
+            ...(existsState.query.optional?.length ? { optional: existsState.query.optional } : {}),
+            ...(existsState.query.binds?.length ? { binds: existsState.query.binds } : {}),
+            ...(existsState.query.filters?.length ? { filters: existsState.query.filters } : {}),
+        };
+    }
+    notExistsPatterns(expression) {
+        if (!isOperationExpression(expression) || expression.operator.toLowerCase() !== 'notexists') {
+            return null;
+        }
+        const pattern = expression.args[0];
+        if (!pattern || !isPattern(pattern)) {
+            throw new UnsupportedSparqlQueryError('FILTER NOT EXISTS without graph pattern fallback to compatibility engine');
+        }
+        return pattern.type === 'group'
+            ? pattern.patterns
+            : [pattern];
+    }
+    existsPatterns(expression) {
+        if (!isOperationExpression(expression) || expression.operator.toLowerCase() !== 'exists') {
+            return null;
+        }
+        const pattern = expression.args[0];
+        if (!pattern || !isPattern(pattern)) {
+            throw new UnsupportedSparqlQueryError('FILTER EXISTS without graph pattern fallback to compatibility engine');
+        }
+        return pattern.type === 'group'
+            ? pattern.patterns
+            : [pattern];
+    }
+    unionBranchPatterns(branch) {
+        return branch.type === 'group'
+            ? branch.patterns
+            : [branch];
+    }
+    compileBgp(pattern, graph, state, optional) {
+        for (const triple of pattern.triples) {
+            for (const queryPattern of this.compileTriple(triple, graph, state)) {
+                state.addPattern(queryPattern, optional);
+            }
+        }
+    }
+    compileGraphPattern(pattern, state, optional, namedGraphScope) {
+        const graph = this.compileScopedGraphTerm(pattern.name, state.basePath, namedGraphScope);
+        if (graph === null) {
+            state.addImpossibleGraphPattern(optional);
+            return;
+        }
+        if (pattern.name.termType === 'Variable') {
+            if (optional) {
+                throw new UnsupportedSparqlQueryError('OPTIONAL GRAPH variable scope fallback to compatibility engine');
+            }
+            if (namedGraphScope) {
+                state.query.filters?.push({
+                    variable: pattern.name.value,
+                    operator: '$in',
+                    values: this.graphScopeFilterValues(namedGraphScope),
+                });
+            }
+            else {
+                state.query.filters?.push({
+                    variable: pattern.name.value,
+                    operator: '$startsWith',
+                    value: state.basePath,
+                });
+            }
+        }
+        this.compilePatterns(pattern.patterns, graph, state, optional, namedGraphScope);
+    }
+    compileScopedGraphTerm(term, basePath, namedGraphScope) {
+        const graph = this.compileGraphTerm(term, basePath);
+        if (!namedGraphScope) {
+            return graph;
+        }
+        if (graph === null) {
+            return null;
+        }
+        if (term.termType === 'Variable') {
+            return graph;
+        }
+        return this.graphScopeContains(namedGraphScope, graph) ? graph : null;
+    }
+    graphScopeContains(scope, graph) {
+        if (isCompiledVariable(scope)) {
+            return false;
+        }
+        if (isRdfJsTerm(scope)) {
+            return (0, n3_1.termToId)(scope) === (0, n3_1.termToId)(graph);
+        }
+        const values = scope.$in;
+        return Array.isArray(values) && values.some((value) => (value && typeof value === 'object' && 'termType' in value && (0, n3_1.termToId)(value) === (0, n3_1.termToId)(graph)));
+    }
+    graphScopeFilterValues(scope) {
+        if (isCompiledVariable(scope)) {
+            throw new UnsupportedSparqlQueryError('GRAPH variable dataset scope fallback to compatibility engine');
+        }
+        if (isRdfJsTerm(scope)) {
+            return [scope];
+        }
+        const values = scope.$in;
+        if (Array.isArray(values) && values.every((value) => value && typeof value === 'object' && 'termType' in value)) {
+            return values;
+        }
+        throw new UnsupportedSparqlQueryError('GRAPH variable dataset scope fallback to compatibility engine');
+    }
+    compileBind(pattern, basePath) {
+        return {
+            variable: pattern.variable.value,
+            expression: this.compileBindExpression(pattern.expression, basePath),
+        };
+    }
+    compileBindExpression(expression, basePath) {
+        return this.compileBindLikeExpression(expression, basePath, 'BIND');
+    }
+    compileBindLikeExpression(expression, basePath, label) {
+        const normalized = this.normalizeFunctionCallExpression(expression);
+        if (isRdfTermExpression(normalized) && !isVariableTerm(normalized)) {
+            return {
+                type: 'term',
+                term: normalized,
+            };
+        }
+        if (isVariableTerm(normalized)) {
+            return {
+                type: 'variable',
+                variable: normalized.value,
+            };
+        }
+        if (!isOperationExpression(normalized)) {
+            throw new UnsupportedSparqlQueryError(`${label} expression fallback to compatibility engine`);
+        }
+        const operator = normalized.operator.toLowerCase();
+        if (operator === 'str') {
+            return {
+                type: 'stringValue',
+                variable: this.expressionVariable(this.expressionArg(normalized.args[0])),
+            };
+        }
+        if (operator === 'strlen') {
+            return {
+                type: 'stringLength',
+                variable: this.stringOperandVariable(this.expressionArg(normalized.args[0])).variable,
+            };
+        }
+        if (operator === 'lcase' || operator === 'lower-case') {
+            return {
+                type: 'lowerCase',
+                expression: this.compileBindExpression(this.expressionArg(normalized.args[0]), basePath),
+            };
+        }
+        if (operator === 'ucase' || operator === 'upper-case') {
+            return {
+                type: 'upperCase',
+                expression: this.compileBindExpression(this.expressionArg(normalized.args[0]), basePath),
+            };
+        }
+        if (operator === 'substr' || operator === 'substring') {
+            return {
+                type: 'substring',
+                expression: this.compileBindExpression(this.expressionArg(normalized.args[0]), basePath),
+                start: this.compileBindExpression(this.expressionArg(normalized.args[1]), basePath),
+                ...(normalized.args[2] === undefined
+                    ? {}
+                    : { length: this.compileBindExpression(this.expressionArg(normalized.args[2]), basePath) }),
+            };
+        }
+        if (operator === 'concat') {
+            return {
+                type: 'concat',
+                expressions: normalized.args.map((arg) => (this.compileBindExpression(this.expressionArg(arg), basePath))),
+            };
+        }
+        if (operator === 'iri' || operator === 'uri') {
+            return {
+                type: 'iri',
+                expression: this.compileBindExpression(this.expressionArg(normalized.args[0]), basePath),
+                base: basePath,
+            };
+        }
+        throw new UnsupportedSparqlQueryError(`${label} ${operator} fallback to compatibility engine`);
+    }
+    compileTriple(triple, graph, state) {
+        const subject = this.compileTerm(triple.subject);
+        const object = this.compileTerm(triple.object);
+        const pathPatterns = this.compilePropertyPath(triple.predicate, subject, object, graph, state);
+        if (pathPatterns) {
+            return pathPatterns;
+        }
+        if (!isSimpleTerm(triple.predicate)) {
+            throw new UnsupportedSparqlQueryError('Property paths fallback to compatibility engine');
+        }
+        return [{
+                graph,
+                subject,
+                predicate: this.compileTerm(triple.predicate),
+                object,
+            }];
+    }
+    compilePropertyPath(predicate, subject, object, graph, state) {
+        if (isSimpleTerm(predicate)) {
+            return null;
+        }
+        const alternative = this.flattenFixedAlternativePath(predicate);
+        if (alternative) {
+            const predicateMatch = { $in: alternative.predicates.map((entry) => entry) };
+            return [
+                alternative.inverse
+                    ? {
+                        graph,
+                        subject: object,
+                        predicate: predicateMatch,
+                        object: subject,
+                    }
+                    : {
+                        graph,
+                        subject,
+                        predicate: predicateMatch,
+                        object,
+                    },
+            ];
+        }
+        const segments = this.flattenFixedLengthPath(predicate);
+        if (!segments) {
+            throw new UnsupportedSparqlQueryError('Property paths fallback to compatibility engine');
+        }
+        if (segments.length === 0) {
+            throw new UnsupportedSparqlQueryError('Empty property paths fallback to compatibility engine');
+        }
+        const patterns = [];
+        let currentSubject = subject;
+        for (const [index, segment] of segments.entries()) {
+            const isLast = index === segments.length - 1;
+            const currentObject = isLast ? object : state.nextPathJoinVariable();
+            const predicate = this.compilePathSegmentPredicate(segment);
+            patterns.push(segment.inverse
+                ? {
+                    graph,
+                    subject: currentObject,
+                    predicate,
+                    object: currentSubject,
+                }
+                : {
+                    graph,
+                    subject: currentSubject,
+                    predicate,
+                    object: currentObject,
+                });
+            currentSubject = currentObject;
+        }
+        return patterns;
+    }
+    compilePathSegmentPredicate(segment) {
+        return segment.predicates.length === 1
+            ? segment.predicates[0]
+            : { $in: segment.predicates.map((entry) => entry) };
+    }
+    flattenFixedLengthPath(path) {
+        return this.flattenFixedLengthPathItem(path, false);
+    }
+    flattenFixedAlternativePath(path) {
+        return this.flattenFixedAlternativePathItem(path, false);
+    }
+    flattenFixedAlternativePathItem(item, inverse) {
+        if (isNamedNodeTerm(item)) {
+            return null;
+        }
+        if (item.pathType === '^' && item.items.length === 1) {
+            return this.flattenFixedAlternativePathItem(item.items[0], !inverse);
+        }
+        if (item.pathType !== '|') {
+            return null;
+        }
+        const predicates = [];
+        for (const nestedItem of item.items) {
+            if (!isNamedNodeTerm(nestedItem)) {
+                return null;
+            }
+            predicates.push(nestedItem);
+        }
+        return predicates.length > 0
+            ? { predicates, inverse }
+            : null;
+    }
+    flattenFixedLengthPathItem(item, inverse) {
+        if (isNamedNodeTerm(item)) {
+            return [{ predicates: [item], inverse }];
+        }
+        if (item.pathType === '^' && item.items.length === 1) {
+            return this.flattenFixedLengthPathItem(item.items[0], !inverse);
+        }
+        if (item.pathType === '|') {
+            const predicates = [];
+            for (const nestedItem of item.items) {
+                if (!isNamedNodeTerm(nestedItem)) {
+                    return null;
+                }
+                predicates.push(nestedItem);
+            }
+            return predicates.length > 0
+                ? [{ predicates, inverse }]
+                : null;
+        }
+        if (item.pathType !== '/') {
+            return null;
+        }
+        const items = inverse ? [...item.items].reverse() : item.items;
+        const segments = [];
+        for (const nestedItem of items) {
+            const nested = this.flattenFixedLengthPathItem(nestedItem, inverse);
+            if (!nested) {
+                return null;
+            }
+            segments.push(...nested);
+        }
+        return segments;
+    }
+    compileGraphTerm(term, basePath) {
+        if (term.termType === 'Variable') {
+            return (0, RdfLocalQueryEngine_1.variable)(term.value);
+        }
+        if (!term.value.startsWith(basePath)) {
+            return null;
+        }
+        return term;
+    }
+    compileTerm(term) {
+        if (term.termType === 'Variable') {
+            return (0, RdfLocalQueryEngine_1.variable)(term.value);
+        }
+        if (term.termType === 'Quad') {
+            throw new UnsupportedSparqlQueryError('RDF-star terms fallback to compatibility engine');
+        }
+        return term;
+    }
+    materializeConstruct(template, rows, graph) {
+        return this.materializeTemplate(template.map((triple) => ({
+            ...triple,
+            graph: graph ?? n3_1.DataFactory.defaultGraph(),
+        })), rows);
+    }
+    materializeDeleteWhere(template, rows) {
+        return this.materializeTemplate(template, rows);
+    }
+    materializeTemplate(template, rows) {
+        const quads = [];
+        const seen = new Set();
+        for (const row of rows) {
+            for (const triple of template) {
+                const graph = this.resolveTemplateTerm(triple.graph, row);
+                const subject = this.resolveTemplateTerm(triple.subject, row);
+                const predicate = this.resolveTemplateTerm(triple.predicate, row);
+                const object = this.resolveTemplateTerm(triple.object, row);
+                if (!graph || !subject || !predicate || !object) {
+                    continue;
+                }
+                if (graph.termType !== 'NamedNode' && graph.termType !== 'DefaultGraph') {
+                    continue;
+                }
+                if (subject.termType !== 'NamedNode' && subject.termType !== 'BlankNode') {
+                    continue;
+                }
+                if (predicate.termType !== 'NamedNode') {
+                    continue;
+                }
+                if (object.termType === 'DefaultGraph') {
+                    continue;
+                }
+                const quad = n3_1.DataFactory.quad(subject, predicate, object, graph);
+                const key = [quad.subject, quad.predicate, quad.object, quad.graph].map((term) => (0, n3_1.termToId)(term)).join('\u001f');
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    quads.push(quad);
+                }
+            }
+        }
+        return quads;
+    }
+    compileConstructTemplate(query) {
+        if (!query.template || query.template.length === 0) {
+            throw new UnsupportedSparqlQueryError('CONSTRUCT without template fallback to compatibility engine');
+        }
+        return query.template.map((triple) => {
+            if (!isSimpleTerm(triple.predicate)) {
+                throw new UnsupportedSparqlQueryError('CONSTRUCT property paths fallback to compatibility engine');
+            }
+            if (triple.predicate.termType !== 'NamedNode' && triple.predicate.termType !== 'Variable') {
+                throw new UnsupportedSparqlQueryError('CONSTRUCT predicates must be IRIs or variables');
+            }
+            return {
+                subject: this.compileTerm(triple.subject),
+                predicate: this.compileTerm(triple.predicate),
+                object: this.compileTerm(triple.object),
+            };
+        });
+    }
+    compileDescribeTargets(query, localQuery) {
+        if (query.variables.length === 1 && query.variables[0] instanceof sparqljs_1.Wildcard) {
+            const variables = visibleSelectVariables(query);
+            if (variables.length === 0) {
+                throw new UnsupportedSparqlQueryError('DESCRIBE wildcard without visible variables fallback to compatibility engine');
+            }
+            const unboundVariable = variables.find((variable) => !queryBindsVariableInRequiredShape(localQuery, variable));
+            if (unboundVariable) {
+                throw new UnsupportedSparqlQueryError('DESCRIBE wildcard variables must be bound by required embedded query patterns');
+            }
+            return variables.map((variable) => (0, RdfLocalQueryEngine_1.variable)(variable));
+        }
+        const targets = query.variables.map((target) => {
+            if (target.termType === 'Variable') {
+                if (!queryBindsVariableInRequiredShape(localQuery, target.value)) {
+                    throw new UnsupportedSparqlQueryError('DESCRIBE variables must be bound by required embedded query patterns');
+                }
+                return (0, RdfLocalQueryEngine_1.variable)(target.value);
+            }
+            if (target.termType === 'NamedNode') {
+                return target;
+            }
+            throw new UnsupportedSparqlQueryError('DESCRIBE targets must be IRIs or bound variables locally');
+        });
+        if (targets.length === 0) {
+            throw new UnsupportedSparqlQueryError('DESCRIBE without targets fallback to compatibility engine');
+        }
+        return targets;
+    }
+    resolveTemplateTerm(term, row) {
+        if (isCompiledVariable(term)) {
+            return row[term.variable];
+        }
+        return term;
+    }
+    compileSelectVariables(query, state) {
+        const localQuery = state.query;
+        if (query.variables.length === 1 && query.variables[0] instanceof sparqljs_1.Wildcard) {
+            if ((localQuery.groupBy?.length ?? 0) > 0) {
+                throw new UnsupportedSparqlQueryError('Wildcard grouped SELECT fallback to compatibility engine');
+            }
+            return visibleSelectVariables(query);
+        }
+        const variables = [];
+        const visibleVariables = visibleSelectVariables(query);
+        for (const variable of query.variables) {
+            if (isSelectVariableTerm(variable)) {
+                variables.push(variable.value);
+                continue;
+            }
+            if (!isVariableExpression(variable)) {
+                throw new UnsupportedSparqlQueryError('Wildcard mixed with explicit SELECT projections fallback to compatibility engine');
+            }
+            if (!isAggregateExpression(variable.expression)) {
+                if ((localQuery.groupBy?.length ?? 0) > 0) {
+                    throw new UnsupportedSparqlQueryError('Grouped SELECT expression projection fallback to compatibility engine');
+                }
+                const alias = variable.variable.value;
+                if (variables.includes(alias)
+                    || visibleVariables.includes(alias)
+                    || (localQuery.binds ?? []).some((bind) => bind.variable === alias)) {
+                    throw new UnsupportedSparqlQueryError('SELECT expression alias is already bound locally');
+                }
+                state.addBind({
+                    variable: alias,
+                    expression: this.compileSelectProjectionExpression(variable.expression, state.basePath),
+                }, false);
+                variables.push(alias);
+                continue;
+            }
+            const aggregate = variable.expression;
+            const compiledAggregate = this.compileAggregateProjection(aggregate, variable.variable.value, state);
+            localQuery.aggregates = [...(localQuery.aggregates ?? []), compiledAggregate];
+            localQuery.aggregate ??= compiledAggregate;
+            variables.push(variable.variable.value);
+        }
+        this.assertGroupProjection(query, localQuery, variables);
+        return variables;
+    }
+    compileAggregateProjection(aggregate, as, state) {
+        const type = this.aggregateType(aggregate.aggregation);
+        const aggregateExpression = aggregate.expression;
+        if (type !== 'count' && isWildcardTerm(aggregateExpression)) {
+            throw new UnsupportedSparqlQueryError(`${type.toUpperCase()}(*) fallback to compatibility engine`);
+        }
+        const variable = isWildcardTerm(aggregateExpression)
+            ? undefined
+            : this.expressionVariable(aggregateExpression);
+        if (type !== 'count') {
+            this.assertNumericAggregateSafe(variable, state);
+        }
+        return {
+            type,
+            as,
+            variable,
+            distinct: aggregate.distinct,
+        };
+    }
+    aggregateType(aggregation) {
+        switch (aggregation.toLowerCase()) {
+            case 'count':
+            case 'sum':
+            case 'avg':
+            case 'min':
+            case 'max':
+                return aggregation.toLowerCase();
+            default:
+                throw new UnsupportedSparqlQueryError(`Aggregate ${aggregation} fallback to compatibility engine`);
+        }
+    }
+    assertNumericAggregateSafe(variable, state) {
+        if (!variable) {
+            throw new UnsupportedSparqlQueryError('Numeric aggregate requires a variable locally');
+        }
+        if (!queryBindsVariableInRequiredShape(state.query, variable)) {
+            throw new UnsupportedSparqlQueryError('Numeric aggregate variable must be bound by required embedded query patterns');
+        }
+        if (!hasNumericGuard(state.query.filters ?? [], variable)) {
+            throw new UnsupportedSparqlQueryError('Numeric aggregate requires FILTER(isNumeric(?var)) locally');
+        }
+    }
+    compileSelectProjectionExpression(expression, basePath) {
+        return this.compileBindLikeExpression(expression, basePath, 'SELECT projection');
+    }
+    compileGroupBy(group, state) {
+        if (group.length === 0) {
+            return undefined;
+        }
+        const groupBy = [];
+        group.forEach((entry, index) => {
+            if (isVariableTerm(entry.expression)) {
+                const groupVariable = entry.variable?.value ?? entry.expression.value;
+                groupBy.push(groupVariable);
+                if (entry.variable && entry.variable.value !== entry.expression.value) {
+                    state.addBind({
+                        variable: entry.variable.value,
+                        expression: {
+                            type: 'variable',
+                            variable: entry.expression.value,
+                        },
+                    }, false);
+                }
+                return;
+            }
+            const groupVariable = entry.variable?.value ?? state.nextGroupVariable(index);
+            state.addBind({
+                variable: groupVariable,
+                expression: this.compileGroupByExpression(entry.expression, state.basePath),
+            }, false);
+            groupBy.push(groupVariable);
+        });
+        state.query.groupBy = groupBy;
+        return groupBy;
+    }
+    compileGroupByExpression(expression, basePath) {
+        return this.compileBindLikeExpression(expression, basePath, 'GROUP BY');
+    }
+    compileHaving(having, state) {
+        if (having.length === 0) {
+            return undefined;
+        }
+        const localQuery = state.query;
+        if ((localQuery.aggregates?.length ?? 0) === 0 && !localQuery.aggregate) {
+            throw new UnsupportedSparqlQueryError('HAVING without aggregate fallback to compatibility engine');
+        }
+        const filters = having.flatMap((expression) => this.compileHavingFilter(expression, state));
+        return filters.length > 0 ? filters : undefined;
+    }
+    compileHavingFilter(expression, state) {
+        const normalized = this.normalizeFunctionCallExpression(expression);
+        if (!isOperationExpression(normalized)) {
+            throw new UnsupportedSparqlQueryError('Only simple HAVING operations are supported locally');
+        }
+        const operator = normalized.operator.toLowerCase();
+        if (operator === '&&') {
+            return normalized.args.flatMap((arg) => this.compileHavingFilter(this.expressionArg(arg), state));
+        }
+        const binary = this.binaryFilter(operator);
+        if (!binary) {
+            throw new UnsupportedSparqlQueryError(`HAVING ${operator} fallback to compatibility engine`);
+        }
+        return [this.compileHavingBinaryFilter(binary, normalized.args[0], normalized.args[1], state)];
+    }
+    compileHavingBinaryFilter(operator, left, right, state) {
+        const leftExpression = this.expressionArg(left);
+        const rightExpression = this.expressionArg(right);
+        const leftAggregate = this.havingAggregateVariableOrUndefined(leftExpression, state);
+        if (leftAggregate) {
+            return {
+                variable: leftAggregate,
+                operator,
+                value: this.filterValue(rightExpression),
+            };
+        }
+        const rightAggregate = this.havingAggregateVariableOrUndefined(rightExpression, state);
+        if (rightAggregate) {
+            return {
+                variable: rightAggregate,
+                operator: this.reverseBinaryFilter(operator),
+                value: this.filterValue(leftExpression),
+            };
+        }
+        throw new UnsupportedSparqlQueryError('HAVING must compare one aggregate with one RDF term locally');
+    }
+    havingAggregateVariableOrUndefined(expression, state) {
+        const localQuery = state.query;
+        const aggregates = localQuery.aggregates ?? (localQuery.aggregate ? [localQuery.aggregate] : []);
+        if (aggregates.length === 0) {
+            return undefined;
+        }
+        if (isVariableExpressionTerm(expression)) {
+            return aggregates.some((aggregate) => aggregate.as === expression.value) ? expression.value : undefined;
+        }
+        if (!isAggregateExpression(expression)) {
+            return undefined;
+        }
+        const type = this.aggregateType(expression.aggregation);
+        const aggregateExpression = expression.expression;
+        const variable = isWildcardTerm(aggregateExpression)
+            ? undefined
+            : this.expressionVariable(aggregateExpression);
+        const matchingAggregate = aggregates.find((aggregate) => (type === aggregate.type
+            && variable === aggregate.variable
+            && expression.distinct === Boolean(aggregate.distinct)));
+        if (matchingAggregate) {
+            return matchingAggregate.as;
+        }
+        if (type !== 'count') {
+            this.assertNumericAggregateSafe(variable, state);
+        }
+        const hiddenAggregate = {
+            type,
+            as: state.nextHavingAggregateVariable(),
+            variable,
+            distinct: expression.distinct,
+        };
+        localQuery.aggregates = [...(localQuery.aggregates ?? []), hiddenAggregate];
+        return hiddenAggregate.as;
+    }
+    assertGroupProjection(query, localQuery, variables) {
+        const groupBy = localQuery.groupBy ?? [];
+        if (groupBy.length === 0) {
+            return;
+        }
+        const aggregates = localQuery.aggregates ?? (localQuery.aggregate ? [localQuery.aggregate] : []);
+        if (aggregates.length === 0) {
+            throw new UnsupportedSparqlQueryError('GROUP BY without aggregate fallback to compatibility engine');
+        }
+        const groupableVariables = new Set([
+            ...localQuery.patterns.flatMap((pattern) => variablesInPattern(pattern)),
+            ...(localQuery.binds ?? []).map((bind) => bind.variable),
+        ]);
+        if (groupBy.some((variableName) => !groupableVariables.has(variableName))) {
+            throw new UnsupportedSparqlQueryError('GROUP BY variables must come from required BGP patterns or local binds');
+        }
+        const groupVariables = new Set(groupBy);
+        const aggregateVariables = new Set();
+        for (const variable of query.variables) {
+            if (isSelectVariableTerm(variable)) {
+                if (!groupVariables.has(variable.value)) {
+                    throw new UnsupportedSparqlQueryError('Grouped SELECT variables must be present in GROUP BY');
+                }
+                continue;
+            }
+            if (isVariableExpression(variable) && isAggregateExpression(variable.expression)) {
+                aggregateVariables.add(variable.variable.value);
+            }
+        }
+        const aggregateAliases = new Set(aggregates.map((aggregate) => aggregate.as));
+        if (aggregateVariables.size !== aggregateAliases.size) {
+            throw new UnsupportedSparqlQueryError('Grouped local queries require aggregate projections to be aggregate aliases');
+        }
+        if ([...aggregateVariables].some((variableName) => !aggregateAliases.has(variableName))) {
+            throw new UnsupportedSparqlQueryError('Grouped local queries require aggregate projections to be aggregate aliases');
+        }
+        if (variables.some((variableName) => !groupVariables.has(variableName) && !aggregateAliases.has(variableName))) {
+            throw new UnsupportedSparqlQueryError('Grouped SELECT projection fallback to compatibility engine');
+        }
+    }
+    compileOrder(order, state) {
+        if (order.length === 0) {
+            return undefined;
+        }
+        return order.map((entry, index) => {
+            if (isVariableTerm(entry.expression)) {
+                return {
+                    variable: entry.expression.value,
+                    direction: entry.descending ? 'desc' : 'asc',
+                };
+            }
+            const orderVariable = state.nextOrderVariable(index);
+            state.addBind({
+                variable: orderVariable,
+                expression: this.compileOrderExpression(entry.expression, state.basePath),
+            }, false);
+            return {
+                variable: orderVariable,
+                direction: entry.descending ? 'desc' : 'asc',
+            };
+        });
+    }
+    compileOrderExpression(expression, basePath) {
+        return this.compileBindLikeExpression(expression, basePath, 'ORDER BY');
+    }
+    compileFilter(expression) {
+        const normalizedExpression = this.normalizeFunctionCallExpression(expression);
+        if (!isOperationExpression(expression)) {
+            if (!normalizedExpression || !isOperationExpression(normalizedExpression)) {
+                throw new UnsupportedSparqlQueryError('Only simple FILTER operations are supported locally');
+            }
+            expression = normalizedExpression;
+        }
+        else {
+            expression = normalizedExpression;
+        }
+        const operator = expression.operator.toLowerCase();
+        if (operator === '&&') {
+            return expression.args.flatMap((arg) => this.compileFilter(this.expressionArg(arg)));
+        }
+        if (operator === '||') {
+            return [this.compileOrFilter(expression)];
+        }
+        if (operator === 'bound') {
+            return [{
+                    variable: this.expressionVariable(this.expressionArg(expression.args[0])),
+                    operator: '$bound',
+                    value: true,
+                }];
+        }
+        const termTest = this.compileTermTestFilter(operator, expression);
+        if (termTest) {
+            return [termTest];
+        }
+        if (operator === '!' || operator === 'not') {
+            return this.compileNegatedFilter(this.expressionArg(expression.args[0]));
+        }
+        if (operator === 'langmatches') {
+            return [this.compileLangMatchesFilter(expression)];
+        }
+        const binary = this.binaryFilter(operator);
+        if (binary) {
+            return [this.compileBinaryFilter(binary, expression.args[0], expression.args[1])];
+        }
+        if (operator === 'in' || operator === 'notin') {
+            const values = expression.args[1];
+            if (!Array.isArray(values)) {
+                throw new UnsupportedSparqlQueryError('FILTER IN tuple fallback to compatibility engine');
+            }
+            const operand = this.stringOperandVariable(this.expressionArg(expression.args[0]));
+            return [{
+                    variable: operand.variable,
+                    operator: operator === 'in' ? '$in' : '$notIn',
+                    operand: operand.operand,
+                    values: values.map((value) => this.filterValue(value)),
+                }];
+        }
+        const stringOperator = this.stringFilter(operator);
+        if (stringOperator) {
+            const [left, right, flags] = expression.args;
+            const leftOperand = this.stringOperandVariable(this.expressionArg(left));
+            return [{
+                    variable: leftOperand.variable,
+                    operator: stringOperator,
+                    operand: leftOperand.operand,
+                    value: this.literalString(this.expressionArg(right)),
+                    flags: operator === 'regex' && flags ? this.literalString(this.expressionArg(flags)) : undefined,
+                }];
+        }
+        throw new UnsupportedSparqlQueryError(`FILTER ${operator} fallback to compatibility engine`);
+    }
+    compileOrFilter(expression) {
+        const branches = this.flattenOrExpressions(expression);
+        let variable;
+        let operand = undefined;
+        let operandInitialized = false;
+        const values = [];
+        const seen = new Set();
+        for (const branch of branches) {
+            const filters = this.compileFilter(branch);
+            if (filters.length !== 1) {
+                throw new UnsupportedSparqlQueryError('FILTER OR only supports equality or IN branches on one variable locally');
+            }
+            const filter = filters[0];
+            if (filter.operator !== '$eq' && filter.operator !== '$in') {
+                throw new UnsupportedSparqlQueryError('FILTER OR only supports equality or IN branches on one variable locally');
+            }
+            if (variable && variable !== filter.variable) {
+                throw new UnsupportedSparqlQueryError('FILTER OR branches must constrain the same variable locally');
+            }
+            if (operandInitialized && operand !== filter.operand) {
+                throw new UnsupportedSparqlQueryError('FILTER OR branches must use the same operand locally');
+            }
+            variable = filter.variable;
+            operand = filter.operand;
+            operandInitialized = true;
+            const branchValues = filter.operator === '$eq'
+                ? filter.value === undefined ? [] : [filter.value]
+                : filter.values ?? [];
+            if (branchValues.length === 0) {
+                throw new UnsupportedSparqlQueryError('FILTER OR branch without values fallback to compatibility engine');
+            }
+            for (const value of branchValues) {
+                const key = this.filterValueKey(value);
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    values.push(value);
+                }
+            }
+        }
+        if (!variable || values.length === 0) {
+            throw new UnsupportedSparqlQueryError('FILTER OR without equality branches fallback to compatibility engine');
+        }
+        return {
+            variable,
+            operator: '$in',
+            operand,
+            values,
+        };
+    }
+    flattenOrExpressions(expression) {
+        if (isOperationExpression(expression) && expression.operator.toLowerCase() === '||') {
+            return expression.args.flatMap((arg) => this.flattenOrExpressions(this.expressionArg(arg)));
+        }
+        return [expression];
+    }
+    filterValueKey(value) {
+        if (value && typeof value === 'object' && 'termType' in value) {
+            return `term:${(0, n3_1.termToId)(value)}`;
+        }
+        return `${typeof value}:${String(value)}`;
+    }
+    compileBinaryFilter(operator, left, right) {
+        const leftExpression = this.expressionArg(left);
+        const rightExpression = this.expressionArg(right);
+        const leftStringLengthVariable = this.stringLengthVariableOrUndefined(leftExpression);
+        const rightStringLengthVariable = this.stringLengthVariableOrUndefined(rightExpression);
+        if (leftStringLengthVariable && rightStringLengthVariable) {
+            return {
+                variable: leftStringLengthVariable,
+                operator,
+                operand: 'stringLength',
+                variable2: rightStringLengthVariable,
+            };
+        }
+        if (leftStringLengthVariable) {
+            return {
+                variable: leftStringLengthVariable,
+                operator,
+                operand: 'stringLength',
+                value: this.filterValue(rightExpression),
+            };
+        }
+        if (rightStringLengthVariable) {
+            return {
+                variable: rightStringLengthVariable,
+                operator: this.reverseBinaryFilter(operator),
+                operand: 'stringLength',
+                value: this.filterValue(leftExpression),
+            };
+        }
+        const leftFunction = this.compileFunctionComparisonFilter(operator, leftExpression, rightExpression);
+        if (leftFunction) {
+            return leftFunction;
+        }
+        const rightFunction = this.compileFunctionComparisonFilter(this.reverseBinaryFilter(operator), rightExpression, leftExpression);
+        if (rightFunction) {
+            return rightFunction;
+        }
+        const leftStringOperand = this.stringOperandVariableOrUndefined(leftExpression);
+        const rightStringOperand = this.stringOperandVariableOrUndefined(rightExpression);
+        if (leftStringOperand && rightStringOperand) {
+            if (leftStringOperand.operand !== rightStringOperand.operand) {
+                throw new UnsupportedSparqlQueryError('FILTER string expression comparison must use matching operands locally');
+            }
+            return {
+                variable: leftStringOperand.variable,
+                operator,
+                operand: leftStringOperand.operand,
+                variable2: rightStringOperand.variable,
+            };
+        }
+        if (leftStringOperand) {
+            return {
+                variable: leftStringOperand.variable,
+                operator,
+                operand: leftStringOperand.operand,
+                value: this.literalString(rightExpression),
+            };
+        }
+        if (rightStringOperand) {
+            return {
+                variable: rightStringOperand.variable,
+                operator: this.reverseBinaryFilter(operator),
+                operand: rightStringOperand.operand,
+                value: this.literalString(leftExpression),
+            };
+        }
+        const leftVariable = this.expressionVariableOrUndefined(leftExpression);
+        const rightVariable = this.expressionVariableOrUndefined(rightExpression);
+        if (leftVariable && !rightVariable) {
+            return {
+                variable: leftVariable,
+                operator,
+                value: this.filterValue(rightExpression),
+            };
+        }
+        if (leftVariable && rightVariable) {
+            return {
+                variable: leftVariable,
+                operator,
+                variable2: rightVariable,
+            };
+        }
+        if (rightVariable && !leftVariable) {
+            return {
+                variable: rightVariable,
+                operator: this.reverseBinaryFilter(operator),
+                value: this.filterValue(leftExpression),
+            };
+        }
+        throw new UnsupportedSparqlQueryError('FILTER comparison must compare one variable with one RDF term locally');
+    }
+    compileTermTestFilter(operator, expression) {
+        switch (operator) {
+            case 'isiri':
+            case 'isuri':
+                return {
+                    variable: this.expressionVariable(this.expressionArg(expression.args[0])),
+                    operator: '$termType',
+                    value: 'iri',
+                };
+            case 'isblank':
+                return {
+                    variable: this.expressionVariable(this.expressionArg(expression.args[0])),
+                    operator: '$termType',
+                    value: 'blank',
+                };
+            case 'isliteral':
+                return {
+                    variable: this.expressionVariable(this.expressionArg(expression.args[0])),
+                    operator: '$termType',
+                    value: 'literal',
+                };
+            case 'isnumeric':
+                return {
+                    variable: this.expressionVariable(this.expressionArg(expression.args[0])),
+                    operator: '$termType',
+                    value: 'numeric',
+                };
+            case 'sameterm': {
+                const leftExpression = this.expressionArg(expression.args[0]);
+                const rightExpression = this.expressionArg(expression.args[1]);
+                const leftVariable = this.expressionVariableOrUndefined(leftExpression);
+                const rightVariable = this.expressionVariableOrUndefined(rightExpression);
+                if (leftVariable && rightVariable) {
+                    return {
+                        variable: leftVariable,
+                        operator: '$sameTerm',
+                        variable2: rightVariable,
+                    };
+                }
+                if (leftVariable) {
+                    return {
+                        variable: leftVariable,
+                        operator: '$sameTerm',
+                        value: this.filterValue(rightExpression),
+                    };
+                }
+                if (rightVariable) {
+                    return {
+                        variable: rightVariable,
+                        operator: '$sameTerm',
+                        value: this.filterValue(leftExpression),
+                    };
+                }
+                throw new UnsupportedSparqlQueryError('sameTerm FILTER must compare at least one variable locally');
+            }
+            default:
+                return null;
+        }
+    }
+    compileFunctionComparisonFilter(operator, functionExpression, valueExpression) {
+        if (operator !== '$eq' && operator !== '$ne') {
+            return null;
+        }
+        if (!isOperationExpression(functionExpression)) {
+            return null;
+        }
+        const functionOperator = functionExpression.operator.toLowerCase();
+        if (functionOperator === 'lang') {
+            return {
+                variable: this.expressionVariable(this.expressionArg(functionExpression.args[0])),
+                operator: operator === '$eq' ? '$lang' : '$notLang',
+                value: this.literalString(valueExpression),
+            };
+        }
+        if (functionOperator === 'datatype') {
+            const value = this.filterValue(valueExpression);
+            if (!isNamedNodeTerm(value)) {
+                throw new UnsupportedSparqlQueryError('DATATYPE FILTER value must be an IRI locally');
+            }
+            return {
+                variable: this.expressionVariable(this.expressionArg(functionExpression.args[0])),
+                operator: operator === '$eq' ? '$datatype' : '$notDatatype',
+                value,
+            };
+        }
+        return null;
+    }
+    stringLengthVariableOrUndefined(expression) {
+        const normalized = this.normalizeFunctionCallExpression(expression);
+        if (!isOperationExpression(normalized) || normalized.operator.toLowerCase() !== 'strlen') {
+            return undefined;
+        }
+        return this.stringOperandVariable(this.expressionArg(normalized.args[0])).variable;
+    }
+    stringValueVariableOrUndefined(expression) {
+        const operand = this.stringOperandVariableOrUndefined(expression);
+        return operand?.operand === 'stringValue' ? operand.variable : undefined;
+    }
+    stringOperandVariable(expression) {
+        const stringOperand = this.stringOperandVariableOrUndefined(expression);
+        if (stringOperand) {
+            return stringOperand;
+        }
+        return {
+            variable: this.expressionVariable(expression),
+        };
+    }
+    stringOperandVariableOrUndefined(expression) {
+        if (isStrOperation(expression)) {
+            return {
+                variable: this.expressionVariable(this.expressionArg(expression.args[0])),
+                operand: 'stringValue',
+            };
+        }
+        const normalized = this.normalizeFunctionCallExpression(expression);
+        if (!isOperationExpression(normalized)) {
+            return undefined;
+        }
+        const operator = normalized.operator.toLowerCase();
+        if (operator !== 'lcase' && operator !== 'lower-case' && operator !== 'ucase' && operator !== 'upper-case') {
+            return undefined;
+        }
+        const innerOperand = this.stringOperandVariableOrUndefined(this.expressionArg(normalized.args[0]));
+        if (!innerOperand || innerOperand.operand !== 'stringValue') {
+            return undefined;
+        }
+        return {
+            variable: innerOperand.variable,
+            operand: operator === 'lcase' || operator === 'lower-case' ? 'lowerStringValue' : 'upperStringValue',
+        };
+    }
+    compileLangMatchesFilter(expression) {
+        const langExpression = this.expressionArg(expression.args[0]);
+        if (!isOperationExpression(langExpression) || langExpression.operator.toLowerCase() !== 'lang') {
+            throw new UnsupportedSparqlQueryError('LANGMATCHES first argument must be LANG(?var) locally');
+        }
+        return {
+            variable: this.expressionVariable(this.expressionArg(langExpression.args[0])),
+            operator: '$langMatches',
+            value: this.literalString(this.expressionArg(expression.args[1])),
+        };
+    }
+    compileValuesRows(rows, state, optional = false) {
+        if (rows.length === 0) {
+            return;
+        }
+        const keys = unique(rows.flatMap((row) => Object.keys(row))).sort();
+        if (keys.length === 0) {
+            return;
+        }
+        const hasUnboundValues = rows.some((row) => keys.some((key) => !row[key]));
+        if (!optional && keys.length === 1 && !hasUnboundValues) {
+            const key = keys[0];
+            state.query.filters?.push({
+                variable: key.replace(/^\?/, ''),
+                operator: '$in',
+                values: rows.map((row) => this.filterValue(row[key])),
+                source: 'values',
+            });
+            return;
+        }
+        const variables = keys.map((key) => key.replace(/^\?/, ''));
+        state.addValuesSource({
+            variables,
+            rows: rows.map((row) => {
+                const binding = {};
+                keys.forEach((key, index) => {
+                    const expression = row[key];
+                    if (expression) {
+                        binding[variables[index]] = this.valuesTerm(expression);
+                    }
+                });
+                return binding;
+            }),
+        }, optional);
+    }
+    valuesTerm(expression) {
+        const value = this.filterValue(expression);
+        if (!isRdfJsTerm(value)) {
+            throw new UnsupportedSparqlQueryError('VALUES rows must contain RDF terms locally');
+        }
+        return value;
+    }
+    compileNegatedFilter(expression) {
+        if (!isOperationExpression(expression)) {
+            throw new UnsupportedSparqlQueryError('Only safely negated FILTER operations are supported locally');
+        }
+        const operator = expression.operator.toLowerCase();
+        if (operator === 'bound') {
+            return [{
+                    variable: this.expressionVariable(this.expressionArg(expression.args[0])),
+                    operator: '$bound',
+                    value: false,
+                }];
+        }
+        if (operator === '||') {
+            const filter = this.compileOrFilter(expression);
+            return [{
+                    ...filter,
+                    operator: '$notIn',
+                }];
+        }
+        const binary = this.negatedBinaryFilter(operator);
+        if (binary) {
+            return [this.compileBinaryFilter(binary, expression.args[0], expression.args[1])];
+        }
+        if (operator === 'in' || operator === 'notin') {
+            const values = expression.args[1];
+            if (!Array.isArray(values)) {
+                throw new UnsupportedSparqlQueryError('FILTER negated IN tuple fallback to compatibility engine');
+            }
+            const operand = this.stringOperandVariable(this.expressionArg(expression.args[0]));
+            return [{
+                    variable: operand.variable,
+                    operator: operator === 'in' ? '$notIn' : '$in',
+                    operand: operand.operand,
+                    values: values.map((value) => this.filterValue(value)),
+                }];
+        }
+        throw new UnsupportedSparqlQueryError(`FILTER !${operator} fallback to compatibility engine`);
+    }
+    expressionArg(value) {
+        if (!value || value.type === 'bgp') {
+            throw new UnsupportedSparqlQueryError('Unsupported FILTER argument');
+        }
+        return this.normalizeFunctionCallExpression(value);
+    }
+    expressionVariable(expression) {
+        if (isVariableTerm(expression)) {
+            return expression.value;
+        }
+        throw new UnsupportedSparqlQueryError('Only variable expressions are supported in this query position');
+    }
+    expressionVariableOrUndefined(expression) {
+        return isVariableTerm(expression) ? expression.value : undefined;
+    }
+    filterValue(expression) {
+        if (isRdfTermExpression(expression)) {
+            return expression;
+        }
+        throw new UnsupportedSparqlQueryError('Only RDF term filter values are supported locally');
+    }
+    literalString(expression) {
+        if (isLiteralTerm(expression)) {
+            return expression.value;
+        }
+        throw new UnsupportedSparqlQueryError('String FILTER arguments must be literals');
+    }
+    binaryFilter(operator) {
+        switch (operator) {
+            case '=':
+                return '$eq';
+            case '!=':
+                return '$ne';
+            case '>':
+                return '$gt';
+            case '>=':
+                return '$gte';
+            case '<':
+                return '$lt';
+            case '<=':
+                return '$lte';
+            default:
+                return null;
+        }
+    }
+    reverseBinaryFilter(operator) {
+        switch (operator) {
+            case '$eq':
+            case '$ne':
+                return operator;
+            case '$gt':
+                return '$lt';
+            case '$gte':
+                return '$lte';
+            case '$lt':
+                return '$gt';
+            case '$lte':
+                return '$gte';
+            default:
+                throw new UnsupportedSparqlQueryError(`FILTER ${operator} cannot be reversed locally`);
+        }
+    }
+    negatedBinaryFilter(operator) {
+        switch (operator) {
+            case '=':
+                return '$ne';
+            case '!=':
+                return '$eq';
+            case '>':
+                return '$lte';
+            case '>=':
+                return '$lt';
+            case '<':
+                return '$gte';
+            case '<=':
+                return '$gt';
+            default:
+                return null;
+        }
+    }
+    stringFilter(operator) {
+        switch (operator) {
+            case 'strstarts':
+                return '$startsWith';
+            case 'contains':
+                return '$contains';
+            case 'strends':
+                return '$endsWith';
+            case 'regex':
+                return '$regex';
+            default:
+                return null;
+        }
+    }
+    normalizeFunctionCallExpression(expression) {
+        if (!isFunctionCallExpression(expression)) {
+            return expression;
+        }
+        if (expression.distinct) {
+            throw new UnsupportedSparqlQueryError('DISTINCT function calls fallback to compatibility engine');
+        }
+        const functionIri = typeof expression.function === 'string'
+            ? expression.function
+            : expression.function.value;
+        const operator = this.xpathFunctionOperator(functionIri);
+        if (!operator) {
+            throw new UnsupportedSparqlQueryError(`Unsupported SPARQL function ${functionIri} fallback to compatibility engine`);
+        }
+        return {
+            type: 'operation',
+            operator,
+            args: expression.args.map((arg) => (Array.isArray(arg)
+                ? arg.map((item) => this.normalizeFunctionCallExpression(this.expressionArg(item)))
+                : this.normalizeFunctionCallExpression(this.expressionArg(arg)))),
+        };
+    }
+    xpathFunctionOperator(iri) {
+        if (!iri.startsWith(XPATH_FUNCTION_NS)) {
+            return null;
+        }
+        switch (iri.slice(XPATH_FUNCTION_NS.length).toLowerCase()) {
+            case 'concat':
+                return 'concat';
+            case 'contains':
+                return 'contains';
+            case 'starts-with':
+                return 'strstarts';
+            case 'ends-with':
+                return 'strends';
+            case 'matches':
+                return 'regex';
+            case 'string-length':
+                return 'strlen';
+            case 'lower-case':
+                return 'lcase';
+            case 'upper-case':
+                return 'ucase';
+            case 'substring':
+                return 'substring';
+            case 'langmatches':
+                return 'langmatches';
+            default:
+                return null;
+        }
+    }
+}
+exports.RdfSparqlAdapter = RdfSparqlAdapter;
+class CompileState {
+    constructor(basePath, skipMinusSharedVariableCheck = false) {
+        this.basePath = basePath;
+        this.skipMinusSharedVariableCheck = skipMinusSharedVariableCheck;
+        this.query = {
+            patterns: [],
+            unions: [],
+            optional: [],
+            filters: [],
+        };
+        this.optionalStack = [];
+        this.pathJoinVariableIndex = 0;
+        this.groupVariableIndex = 0;
+        this.orderVariableIndex = 0;
+        this.havingAggregateVariableIndex = 0;
+    }
+    addPattern(pattern, optional) {
+        if (optional) {
+            this.currentOptionalFrame().patterns.push(this.scopePattern(pattern));
+            return;
+        }
+        this.query.patterns.push(this.scopePattern(pattern));
+    }
+    addImpossibleGraphPattern(optional) {
+        const impossible = n3_1.DataFactory.namedNode(`${this.basePath}__outside_graph_scope__`);
+        this.addPattern({ graph: impossible }, optional);
+    }
+    startOptional() {
+        this.optionalStack.push({
+            patterns: [],
+            filters: [],
+            binds: [],
+            unions: [],
+            values: [],
+            optional: [],
+            minus: [],
+            exists: [],
+        });
+    }
+    finishOptional() {
+        const frame = this.optionalStack.pop();
+        if (!frame) {
+            throw new UnsupportedSparqlQueryError('OPTIONAL scope fallback to compatibility engine');
+        }
+        if (frame.patterns.length > 0
+            || frame.filters.length > 0
+            || frame.binds.length > 0
+            || frame.unions.length > 0
+            || frame.values.length > 0
+            || frame.optional.length > 0
+            || frame.minus.length > 0
+            || frame.exists.length > 0) {
+            const optionalGroup = {
+                patterns: frame.patterns,
+                ...(frame.values.length ? { values: frame.values } : {}),
+                ...(frame.unions.length ? { unions: frame.unions } : {}),
+                ...(frame.optional.length ? { optional: frame.optional } : {}),
+                ...(frame.minus.length ? { minus: frame.minus } : {}),
+                ...(frame.exists.length ? { exists: frame.exists } : {}),
+                ...(frame.binds.length ? { binds: frame.binds } : {}),
+                ...(frame.filters.length > 0 ? { filters: frame.filters } : {}),
+            };
+            const parent = this.peekOptionalFrame();
+            if (parent) {
+                parent.optional.push(optionalGroup);
+            }
+            else {
+                this.query.optional?.push(optionalGroup);
+            }
+        }
+    }
+    addOptionalFilters(filters) {
+        this.currentOptionalFrame().filters.push(...filters);
+    }
+    addBind(bind, optional) {
+        if (optional) {
+            this.currentOptionalFrame().binds.push(bind);
+            return;
+        }
+        this.query.binds ??= [];
+        this.query.binds.push(bind);
+    }
+    addOptionalUnion(branches) {
+        this.currentOptionalFrame().unions.push({ branches });
+    }
+    addUnion(branches) {
+        this.query.unions?.push({ branches });
+    }
+    addOptionalMinus(group) {
+        this.currentOptionalFrame().minus.push(group);
+    }
+    addMinus(group) {
+        this.query.minus ??= [];
+        this.query.minus.push(group);
+    }
+    addOptionalExists(group) {
+        this.currentOptionalFrame().exists.push(group);
+    }
+    addExists(group) {
+        this.query.exists ??= [];
+        this.query.exists.push(group);
+    }
+    addValuesSource(source, optional) {
+        if (optional) {
+            this.currentOptionalFrame().values.push(source);
+            return;
+        }
+        this.query.values ??= [];
+        this.query.values.push(source);
+    }
+    nextPathJoinVariable() {
+        this.pathJoinVariableIndex += 1;
+        return (0, RdfLocalQueryEngine_1.variable)(`${PATH_JOIN_VARIABLE_PREFIX}_${this.pathJoinVariableIndex}`);
+    }
+    nextGroupVariable(index) {
+        this.groupVariableIndex += 1;
+        return `__rdf_group_${index}_${this.groupVariableIndex}`;
+    }
+    nextOrderVariable(index) {
+        this.orderVariableIndex += 1;
+        return `__rdf_order_${index}_${this.orderVariableIndex}`;
+    }
+    nextHavingAggregateVariable() {
+        this.havingAggregateVariableIndex += 1;
+        return `__rdf_having_aggregate_${this.havingAggregateVariableIndex}`;
+    }
+    assertValuesVariablesBoundByRequiredPatterns() {
+        for (const source of this.query.values ?? []) {
+            for (const variable of source.variables) {
+                if (!this.isVariableBoundByRequiredShape(variable)) {
+                    throw new UnsupportedSparqlQueryError('VALUES must constrain a variable from every required embedded query branch');
+                }
+            }
+        }
+        for (const filter of this.query.filters ?? []) {
+            if (filter.operator !== '$in' || filter.source !== 'values') {
+                continue;
+            }
+            if (!this.isVariableBoundByRequiredShape(filter.variable)) {
+                throw new UnsupportedSparqlQueryError('VALUES must constrain a variable from every required embedded query branch');
+            }
+        }
+    }
+    assertBindVariablesSafe() {
+        const bound = new Set();
+        for (const variableName of variablesInPatterns(this.query.patterns)) {
+            bound.add(variableName);
+        }
+        for (const unionGroup of this.query.unions ?? []) {
+            for (const branch of unionGroup.branches) {
+                for (const variableName of variablesInPatterns(branch.patterns)) {
+                    bound.add(variableName);
+                }
+                for (const bind of branch.binds ?? []) {
+                    for (const dependency of variablesInBindExpression(bind.expression)) {
+                        if (!bound.has(dependency)) {
+                            throw new UnsupportedSparqlQueryError('BIND dependency must be bound before use locally');
+                        }
+                    }
+                    bound.add(bind.variable);
+                }
+            }
+        }
+        for (const bind of this.query.binds ?? []) {
+            for (const dependency of variablesInBindExpression(bind.expression)) {
+                if (!bound.has(dependency)) {
+                    throw new UnsupportedSparqlQueryError('BIND dependency must be bound before use locally');
+                }
+            }
+            bound.add(bind.variable);
+        }
+        for (const rawOptionalGroup of this.query.optional ?? []) {
+            assertOptionalBindVariablesSafe(rawOptionalGroup, bound);
+        }
+    }
+    assertDependentGroupsShareRequiredVariables() {
+        if (this.skipMinusSharedVariableCheck) {
+            return;
+        }
+        for (const minusGroup of this.query.minus ?? []) {
+            const shared = variablesInDependentGroup(minusGroup)
+                .some((variableName) => queryBindsVariableInRequiredShape(this.query, variableName));
+            if (!shared) {
+                throw new UnsupportedSparqlQueryError('MINUS must share a required query variable locally');
+            }
+        }
+        for (const existsGroup of this.query.exists ?? []) {
+            const shared = variablesInDependentGroup(existsGroup)
+                .some((variableName) => queryBindsVariableInRequiredShape(this.query, variableName));
+            if (!shared) {
+                throw new UnsupportedSparqlQueryError('FILTER EXISTS must share a required query variable locally');
+            }
+        }
+        const requiredBound = variablesBoundByRequiredShape(this.query);
+        for (const optionalGroup of this.query.optional ?? []) {
+            assertOptionalDependentGroupsShareVariables(normalizeOptionalGroupForAdapter(optionalGroup), requiredBound);
+        }
+    }
+    isVariableBoundByRequiredShape(variableName) {
+        return queryBindsVariableInRequiredShape(this.query, variableName);
+    }
+    scopePattern(pattern) {
+        return pattern.graph ? pattern : { ...pattern, graph: { $startsWith: this.basePath } };
+    }
+    currentOptionalFrame() {
+        const frame = this.peekOptionalFrame();
+        if (!frame) {
+            throw new UnsupportedSparqlQueryError('OPTIONAL scope fallback to compatibility engine');
+        }
+        return frame;
+    }
+    peekOptionalFrame() {
+        return this.optionalStack[this.optionalStack.length - 1];
+    }
+}
+function isVariableTerm(value) {
+    return Boolean(value && 'termType' in value && value.termType === 'Variable');
+}
+function isSelectVariableTerm(value) {
+    return Boolean(value && 'termType' in value && value.termType === 'Variable');
+}
+function isVariableExpression(value) {
+    return Boolean(value && 'expression' in value && 'variable' in value);
+}
+function isVariableExpressionTerm(value) {
+    return Boolean(value && 'termType' in value && value.termType === 'Variable');
+}
+function isOperationExpression(value) {
+    return Boolean(value && 'type' in value && value.type === 'operation');
+}
+function isStrOperation(value) {
+    return isOperationExpression(value) && value.operator.toLowerCase() === 'str';
+}
+function isFunctionCallExpression(value) {
+    return Boolean(value && 'type' in value && value.type === 'functionCall');
+}
+function isAggregateExpression(value) {
+    return Boolean(value && 'type' in value && value.type === 'aggregate');
+}
+function isLiteralTerm(value) {
+    return Boolean(value && 'termType' in value && value.termType === 'Literal');
+}
+function isWildcardTerm(value) {
+    return value instanceof sparqljs_1.Wildcard;
+}
+function isRdfTermExpression(value) {
+    return Boolean(value && 'termType' in value && value.termType !== 'Quad');
+}
+function isNamedNodeTerm(value) {
+    return Boolean(value && typeof value === 'object' && 'termType' in value && value.termType === 'NamedNode');
+}
+function isRdfJsTerm(value) {
+    return Boolean(value && typeof value === 'object' && 'termType' in value);
+}
+function isSimpleTerm(value) {
+    return Boolean(value && 'termType' in value);
+}
+function visibleSelectVariables(query) {
+    const variables = new Set();
+    for (const pattern of query.where ?? []) {
+        collectPatternVariables(pattern, variables);
+    }
+    for (const row of query.values ?? []) {
+        for (const key of Object.keys(row)) {
+            variables.add(key.replace(/^\?/, ''));
+        }
+    }
+    return [...variables];
+}
+function collectPatternVariables(pattern, variables) {
+    switch (pattern.type) {
+        case 'bgp':
+            for (const triple of pattern.triples) {
+                collectTripleVariables(triple, variables);
+            }
+            break;
+        case 'graph':
+            if (pattern.name.termType === 'Variable') {
+                variables.add(pattern.name.value);
+            }
+            for (const child of pattern.patterns) {
+                collectPatternVariables(child, variables);
+            }
+            break;
+        case 'optional':
+        case 'group':
+        case 'union':
+        case 'minus':
+        case 'service':
+            for (const child of pattern.patterns) {
+                collectPatternVariables(child, variables);
+            }
+            break;
+        case 'filter':
+            collectExpressionVariables(pattern.expression, variables);
+            break;
+        case 'bind':
+            collectExpressionVariables(pattern.expression, variables);
+            variables.add(pattern.variable.value);
+            break;
+        case 'values':
+            for (const row of pattern.values) {
+                for (const key of Object.keys(row)) {
+                    variables.add(key.replace(/^\?/, ''));
+                }
+            }
+            break;
+        default:
+            if ('queryType' in pattern) {
+                for (const child of pattern.where ?? []) {
+                    collectPatternVariables(child, variables);
+                }
+            }
+            break;
+    }
+}
+function collectTripleVariables(triple, variables) {
+    collectTermVariables(triple.subject, variables);
+    if (isSimpleTerm(triple.predicate)) {
+        collectTermVariables(triple.predicate, variables);
+    }
+    else {
+        collectPathVariables(triple.predicate, variables);
+    }
+    collectTermVariables(triple.object, variables);
+}
+function collectPathVariables(path, variables) {
+    for (const item of path.items) {
+        if (isSimpleTerm(item)) {
+            collectTermVariables(item, variables);
+        }
+        else {
+            collectPathVariables(item, variables);
+        }
+    }
+}
+function collectExpressionVariables(expression, variables) {
+    if (isVariableTerm(expression)) {
+        variables.add(expression.value);
+        return;
+    }
+    if (!expression || typeof expression !== 'object' || !('type' in expression)) {
+        return;
+    }
+    if (isOperationExpression(expression) || isFunctionCallExpression(expression)) {
+        for (const arg of expression.args) {
+            if (Array.isArray(arg)) {
+                for (const item of arg) {
+                    collectExpressionVariables(item, variables);
+                }
+            }
+            else if (arg && !isPattern(arg)) {
+                collectExpressionVariables(arg, variables);
+            }
+        }
+        return;
+    }
+    if (isAggregateExpression(expression) && !isWildcardTerm(expression.expression)) {
+        collectExpressionVariables(expression.expression, variables);
+    }
+}
+function collectTermVariables(term, variables) {
+    if (term.termType === 'Variable') {
+        variables.add(term.value);
+    }
+}
+function isPattern(value) {
+    return Boolean(value
+        && typeof value === 'object'
+        && 'type' in value
+        && [
+            'bgp',
+            'optional',
+            'union',
+            'group',
+            'graph',
+            'minus',
+            'service',
+            'filter',
+            'bind',
+            'values',
+            'query',
+        ].includes(value.type));
+}
+function isCompiledVariable(value) {
+    return Boolean(value && typeof value === 'object' && 'variable' in value);
+}
+function unique(values) {
+    return [...new Set(values)];
+}
+function uniqueTerms(values) {
+    const seen = new Set();
+    return values.filter((value) => {
+        const key = (0, n3_1.termToId)(value);
+        if (seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    });
+}
+function variablesInPattern(pattern) {
+    const values = [pattern.graph, pattern.subject, pattern.predicate, pattern.object];
+    return values
+        .filter((value) => Boolean(value && typeof value === 'object' && 'variable' in value))
+        .map((value) => value.variable);
+}
+function patternsBindVariable(patterns, variableName) {
+    return patterns.some((pattern) => variablesInPattern(pattern).includes(variableName));
+}
+function variablesInPatterns(patterns) {
+    return unique(patterns.flatMap((pattern) => variablesInPattern(pattern)));
+}
+function variablesBoundByOptionalGroup(optionalGroup) {
+    return unique([
+        ...variablesInPatterns(optionalGroup.patterns),
+        ...variablesInValuesSources(optionalGroup.values ?? []),
+        ...variablesInUnionGroups(optionalGroup.unions ?? []),
+        ...((optionalGroup.binds ?? []).map((bind) => bind.variable)),
+    ]);
+}
+function variablesInUnionGroups(unions) {
+    return unique(unions.flatMap((unionGroup) => (unionGroup.branches.flatMap((branch) => [
+        ...variablesInPatterns(branch.patterns),
+        ...variablesInValuesSources(branch.values ?? []),
+        ...((branch.binds ?? []).map((bind) => bind.variable)),
+    ]))));
+}
+function variablesBoundByRequiredShape(query) {
+    return new Set([
+        ...variablesInPatterns(query.patterns),
+        ...variablesInValuesSources(query.values ?? []),
+        ...variablesInUnionGroups(query.unions ?? []),
+        ...((query.binds ?? []).map((bind) => bind.variable)),
+    ]);
+}
+function hasNumericGuard(filters, variableName) {
+    return filters.some((filter) => (filter.variable === variableName
+        && filter.operator === '$termType'
+        && filter.value === 'numeric'));
+}
+function variablesInDependentGroup(group) {
+    return unique([
+        ...variablesInPatterns(group.patterns),
+        ...variablesInValuesSources(group.values ?? []),
+        ...variablesInUnionGroups(group.unions ?? []),
+        ...((group.binds ?? []).map((bind) => bind.variable)),
+        ...variablesBoundByNestedOptionalGroups(group.optional ?? []),
+    ]);
+}
+function variablesBoundByNestedOptionalGroups(groups) {
+    return unique(groups.flatMap((group) => variablesBoundByOptionalGroup(normalizeOptionalGroupForAdapter(group))));
+}
+function variablesInValuesSources(sources) {
+    return unique(sources.flatMap((source) => source.variables));
+}
+function variablesInBindExpression(expression) {
+    switch (expression.type) {
+        case 'term':
+            return [];
+        case 'variable':
+        case 'stringValue':
+        case 'stringLength':
+            return [expression.variable];
+        case 'lowerCase':
+        case 'upperCase':
+            return variablesInBindExpression(expression.expression);
+        case 'substring':
+            return unique([
+                ...variablesInBindExpression(expression.expression),
+                ...variablesInBindExpression(expression.start),
+                ...(expression.length ? variablesInBindExpression(expression.length) : []),
+            ]);
+        case 'concat':
+            return unique(expression.expressions.flatMap((item) => variablesInBindExpression(item)));
+        case 'iri':
+            return variablesInBindExpression(expression.expression);
+        default: {
+            const exhaustive = expression;
+            return exhaustive;
+        }
+    }
+}
+function assertOptionalBindVariablesSafe(rawOptionalGroup, outerBound) {
+    const optionalGroup = normalizeOptionalGroupForAdapter(rawOptionalGroup);
+    const optionalBound = new Set(outerBound);
+    for (const variableName of variablesInPatterns(optionalGroup.patterns)) {
+        optionalBound.add(variableName);
+    }
+    for (const variableName of variablesInValuesSources(optionalGroup.values ?? [])) {
+        optionalBound.add(variableName);
+    }
+    for (const unionGroup of optionalGroup.unions ?? []) {
+        for (const branch of unionGroup.branches) {
+            const branchBound = new Set(optionalBound);
+            for (const variableName of variablesInPatterns(branch.patterns)) {
+                branchBound.add(variableName);
+            }
+            for (const variableName of variablesInValuesSources(branch.values ?? [])) {
+                branchBound.add(variableName);
+            }
+            for (const bind of branch.binds ?? []) {
+                assertBindDependenciesBound(bind, branchBound);
+                branchBound.add(bind.variable);
+            }
+            for (const variableName of branchBound) {
+                optionalBound.add(variableName);
+            }
+        }
+    }
+    for (const bind of optionalGroup.binds ?? []) {
+        assertBindDependenciesBound(bind, optionalBound);
+        optionalBound.add(bind.variable);
+    }
+    for (const nestedOptionalGroup of optionalGroup.optional ?? []) {
+        assertOptionalBindVariablesSafe(nestedOptionalGroup, optionalBound);
+    }
+}
+function assertOptionalDependentGroupsShareVariables(optionalGroup, outerBound = new Set()) {
+    const bound = new Set(outerBound);
+    for (const variableName of variablesBoundByOptionalGroup(optionalGroup)) {
+        bound.add(variableName);
+    }
+    for (const minusGroup of optionalGroup.minus ?? []) {
+        const shared = variablesInDependentGroup(minusGroup).some((variableName) => bound.has(variableName));
+        if (!shared) {
+            throw new UnsupportedSparqlQueryError('OPTIONAL MINUS must share a locally bound optional variable');
+        }
+    }
+    for (const existsGroup of optionalGroup.exists ?? []) {
+        const shared = variablesInDependentGroup(existsGroup).some((variableName) => bound.has(variableName));
+        if (!shared) {
+            throw new UnsupportedSparqlQueryError('OPTIONAL FILTER EXISTS must share a locally bound optional variable');
+        }
+    }
+    for (const nestedOptionalGroup of optionalGroup.optional ?? []) {
+        assertOptionalDependentGroupsShareVariables(normalizeOptionalGroupForAdapter(nestedOptionalGroup), bound);
+    }
+}
+function assertBindDependenciesBound(bind, bound) {
+    for (const dependency of variablesInBindExpression(bind.expression)) {
+        if (!bound.has(dependency)) {
+            throw new UnsupportedSparqlQueryError('OPTIONAL BIND dependency must be bound before use locally');
+        }
+    }
+}
+function queryBindsVariableInRequiredShape(query, variableName) {
+    if (patternsBindVariable(query.patterns, variableName)) {
+        return true;
+    }
+    if ((query.unions?.length ?? 0) === 0) {
+        return false;
+    }
+    return (query.unions ?? []).every((group) => (group.branches.every((branch) => patternsBindVariable(branch.patterns, variableName))));
+}
+function normalizeOptionalGroupForAdapter(group) {
+    return Array.isArray(group) ? { patterns: group } : group;
+}
+//# sourceMappingURL=RdfSparqlAdapter.js.map