@_linked/core 2.12.0 → 2.13.0-next.20260706164859

package/lib/cjs/sparql/irToAlgebra.js

@@ -1,2042 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.selectToAlgebra = selectToAlgebra;
-exports.createToAlgebra = createToAlgebra;
-exports.updateToAlgebra = updateToAlgebra;
-exports.buildOwnedCascade = buildOwnedCascade;
-exports.deleteToAlgebra = deleteToAlgebra;
-exports.deleteAllToAlgebra = deleteAllToAlgebra;
-exports.deleteWhereToAlgebra = deleteWhereToAlgebra;
-exports.updateWhereToAlgebra = updateWhereToAlgebra;
-exports.selectToSparql = selectToSparql;
-exports.createToSparql = createToSparql;
-exports.updateToSparql = updateToSparql;
-exports.deleteToSparql = deleteToSparql;
-exports.deleteAllToSparql = deleteAllToSparql;
-exports.deleteWhereToSparql = deleteWhereToSparql;
-exports.updateWhereToSparql = updateWhereToSparql;
-const pathExprToSparql_js_1 = require("../paths/pathExprToSparql.js");
-const sparqlUtils_js_1 = require("./sparqlUtils.js");
-const algebraToString_js_1 = require("./algebraToString.js");
-const rdf_js_1 = require("../ontologies/rdf.js");
-const shacl_js_1 = require("../ontologies/shacl.js");
-const xsd_js_1 = require("../ontologies/xsd.js");
-const normalizePropertyPath_js_1 = require("../paths/normalizePropertyPath.js");
-const ShapeClass_js_1 = require("../utils/ShapeClass.js");
-const QueryContext_js_1 = require("../queries/QueryContext.js");
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-const RDF_TYPE = rdf_js_1.rdf.type.id;
-const XSD_DATETIME = xsd_js_1.xsd.dateTime.id;
-const XSD_BOOLEAN = xsd_js_1.xsd.boolean.id;
-const XSD_INTEGER = xsd_js_1.xsd.integer.id;
-const XSD_DOUBLE = xsd_js_1.xsd.double.id;
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function iriTerm(value) {
-    return { kind: 'iri', value };
-}
-function varTerm(name) {
-    return { kind: 'variable', name };
-}
-function literalTerm(value, datatype) {
-    if (datatype) {
-        return { kind: 'literal', value, datatype };
-    }
-    return { kind: 'literal', value };
-}
-function tripleOf(subject, predicate, object) {
-    return { subject, predicate, object };
-}
-function shouldResolveShapeOrPropertyId(resolvedId) {
-    return !!resolvedId && !resolvedId.startsWith('linked://tmp/');
-}
-function resolveShapeScanIri(shapeId) {
-    var _a;
-    const shapeClass = (0, ShapeClass_js_1.getShapeClass)(shapeId);
-    const targetClassId = (_a = shapeClass === null || shapeClass === void 0 ? void 0 : shapeClass.targetClass) === null || _a === void 0 ? void 0 : _a.id;
-    return shouldResolveShapeOrPropertyId(targetClassId) ? targetClassId : shapeId;
-}
-/**
- * Resolve a SHACL property-shape id to the predicate term used in a triple.
- *
- * - Simple single-IRI path → `{kind:'iri'}` (byte-for-byte unchanged behaviour).
- * - Structured path (sequence / inverse / alternative / …) → `{kind:'path'}` built from the property
- *   shape's `sh:path`, reusing the same `pathExprToSparql` / `collectPathUris` machinery as the
- *   inline-`pathExpr` branches. Without this, structured named-property paths collapsed to a shadow IRI
- *   that matched nothing.
- * - No matching shape / unresolvable → `{kind:'iri'}` of the property id itself (unchanged shadow fallback).
- */
-// Memoizes resolved predicate terms across the many call sites that resolve the
-// same property. Guarded by the shape-registry size so it self-invalidates when
-// new shapes register (e.g. across test-file module instances). Only successful
-// resolutions are cached — a not-found fallback is never stored, so a predicate
-// resolved before its shape registers can still resolve correctly afterwards.
-const predicateTermCache = new Map();
-let predicateTermCacheSize = -1;
-function resolvePropertyPredicateTerm(propertyId) {
-    var _a, _b, _c;
-    const shapeClasses = (0, ShapeClass_js_1.getAllShapeClasses)();
-    if (shapeClasses.size !== predicateTermCacheSize) {
-        predicateTermCache.clear();
-        predicateTermCacheSize = shapeClasses.size;
-    }
-    const cached = predicateTermCache.get(propertyId);
-    if (cached)
-        return cached;
-    for (const shapeClass of shapeClasses.values()) {
-        const propertyShape = (_c = (_b = (_a = shapeClass.shape) === null || _a === void 0 ? void 0 : _a.getPropertyShapes) === null || _b === void 0 ? void 0 : _b.call(_a, true)) === null || _c === void 0 ? void 0 : _c.find((prop) => prop.id === propertyId);
-        if (!propertyShape)
-            continue;
-        const simplePathId = (0, normalizePropertyPath_js_1.getSimplePathId)(propertyShape.path);
-        let term;
-        if (simplePathId !== null) {
-            // Simple single-IRI path: resolve to the IRI, or fall back to the property id
-            // (e.g. unresolvable `linked://tmp/` ids) — unchanged from before.
-            term = iriTerm(shouldResolveShapeOrPropertyId(simplePathId) ? simplePathId : propertyId);
-        }
-        else {
-            // Structured sh:path — emit a property-path predicate instead of a shadow IRI.
-            term = {
-                kind: 'path',
-                value: (0, pathExprToSparql_js_1.pathExprToSparql)(propertyShape.path),
-                uris: (0, pathExprToSparql_js_1.collectPathUris)(propertyShape.path),
-            };
-        }
-        predicateTermCache.set(propertyId, term);
-        return term;
-    }
-    return iriTerm(propertyId);
-}
-/**
- * Resolve the predicate term for a traversal/property node: a structured
- * property-path when an explicit `pathExpr` is present, otherwise the
- * registry-resolved predicate for `property`. Centralizes the invariant that
- * these two branches stay in lockstep across every triple-building site.
- */
-function buildPredicateTerm(spec) {
-    return spec.pathExpr
-        ? {
-            kind: 'path',
-            value: (0, pathExprToSparql_js_1.pathExprToSparql)(spec.pathExpr),
-            uris: (0, pathExprToSparql_js_1.collectPathUris)(spec.pathExpr),
-        }
-        : resolvePropertyPredicateTerm(spec.property);
-}
-/** Produce variable name suffix from the last segment of a property URI. */
-function propertySuffix(propertyUri) {
-    const hashIdx = propertyUri.lastIndexOf('#');
-    if (hashIdx >= 0)
-        return propertyUri.substring(hashIdx + 1);
-    const slashIdx = propertyUri.lastIndexOf('/');
-    return slashIdx >= 0 ? propertyUri.substring(slashIdx + 1) : propertyUri;
-}
-/**
- * Sanitize a string so it's valid in a SPARQL variable name.
- * Replaces any non-alphanumeric/underscore characters with underscores.
- */
-function sanitizeVarName(name) {
-    return name.replace(/[^A-Za-z0-9_]/g, '_');
-}
-const IR_EXPRESSION_KINDS = new Set([
-    'literal_expr', 'property_expr', 'binary_expr', 'logical_expr',
-    'not_expr', 'function_expr', 'aggregate_expr', 'reference_expr',
-    'alias_expr', 'context_property_expr', 'exists_expr', 'in_expr',
-]);
-function isIRExpression(value) {
-    return !!value && typeof value === 'object' && 'kind' in value &&
-        typeof value.kind === 'string' &&
-        IR_EXPRESSION_KINDS.has(value.kind);
-}
-/**
- * Wrap a single node in a LeftJoin, making `right` optional relative to `left`.
- */
-function wrapOptional(left, right) {
-    return { type: 'left_join', left, right };
-}
-/**
- * Join two algebra nodes. If left is null, returns right.
- */
-function joinNodes(left, right) {
-    if (!left)
-        return right;
-    return { type: 'join', left, right };
-}
-function bindingKey(alias, property) {
-    return `${alias}::${property}`;
-}
-function contextAliasKey(contextIri) {
-    return `__ctx__${contextIri}`;
-}
-/**
- * Defense-in-depth: a `reference_expr`/`context_property_expr` must arrive here with its
- * IRI already resolved (lowering's `resolveContextRefs` fills it from `contextName`). If it
- * didn't — an unresolved `{@ctx}` reaching the algebra through some path that bypassed
- * resolution — fail with a clear `UnresolvedContextError` instead of an opaque
- * `undefined.substring` crash deeper in URI formatting.
- */
-function resolvedContextIri(iri, contextName) {
-    if (iri === undefined) {
-        throw new QueryContext_js_1.UnresolvedContextError(contextName !== null && contextName !== void 0 ? contextName : '<unknown>');
-    }
-    return iri;
-}
-function mergeKeySets(...sets) {
-    const merged = new Set();
-    for (const set of sets) {
-        for (const key of set) {
-            merged.add(key);
-        }
-    }
-    return merged;
-}
-function intersectKeySets(sets) {
-    if (sets.length === 0) {
-        return new Set();
-    }
-    const [first, ...rest] = sets;
-    const intersection = new Set(first);
-    for (const value of intersection) {
-        if (!rest.every((set) => set.has(value))) {
-            intersection.delete(value);
-        }
-    }
-    return intersection;
-}
-// ---------------------------------------------------------------------------
-// Pattern helpers
-// ---------------------------------------------------------------------------
-/**
- * Recursively collects all traversal alias target variables from IR patterns.
- * Used to ensure traversal aliases appear in the SELECT projection for result grouping.
- */
-function collectTraversalAliases(patterns) {
-    const aliases = [];
-    for (const p of patterns) {
-        if (p.kind === 'traverse') {
-            aliases.push(p.to);
-        }
-        else if (p.kind === 'join') {
-            aliases.push(...collectTraversalAliases(p.patterns));
-        }
-        else if (p.kind === 'optional') {
-            aliases.push(...collectTraversalAliases([p.pattern]));
-        }
-        else if (p.kind === 'union') {
-            for (const branch of p.branches) {
-                aliases.push(...collectTraversalAliases([branch]));
-            }
-        }
-    }
-    return aliases;
-}
-function buildTraverseTriple(pattern) {
-    const predicate = buildPredicateTerm(pattern);
-    return tripleOf(varTerm(pattern.from), predicate, varTerm(pattern.to));
-}
-function collectTraversePatternsInOrder(patterns, out = []) {
-    for (const pattern of patterns) {
-        switch (pattern.kind) {
-            case 'traverse':
-                out.push(pattern);
-                break;
-            case 'join':
-                collectTraversePatternsInOrder(pattern.patterns, out);
-                break;
-            case 'optional':
-            case 'exists':
-                collectTraversePatternsInOrder([pattern.pattern], out);
-                break;
-            case 'union':
-                for (const branch of pattern.branches) {
-                    collectTraversePatternsInOrder([branch], out);
-                }
-                break;
-            case 'shape_scan':
-            case 'minus':
-                break;
-        }
-    }
-    return out;
-}
-function collectDirectProjectionAliases(query, rootAlias) {
-    const aliases = new Set();
-    for (const item of query.projection) {
-        if (item.expression.kind === 'property_expr') {
-            if (item.expression.sourceAlias !== rootAlias) {
-                aliases.add(item.expression.sourceAlias);
-            }
-        }
-        else if (item.expression.kind === 'alias_expr') {
-            if (item.expression.alias !== rootAlias) {
-                aliases.add(item.expression.alias);
-            }
-        }
-    }
-    return aliases;
-}
-function collectExpressionAliases(expr, aliases) {
-    switch (expr.kind) {
-        case 'property_expr':
-            aliases.add(expr.sourceAlias);
-            break;
-        case 'alias_expr':
-            aliases.add(expr.alias);
-            break;
-        case 'binary_expr':
-            collectExpressionAliases(expr.left, aliases);
-            collectExpressionAliases(expr.right, aliases);
-            break;
-        case 'in_expr':
-            collectExpressionAliases(expr.value, aliases);
-            for (const el of expr.source.list)
-                collectExpressionAliases(el, aliases);
-            break;
-        case 'logical_expr':
-            for (const sub of expr.expressions) {
-                collectExpressionAliases(sub, aliases);
-            }
-            break;
-        case 'not_expr':
-            collectExpressionAliases(expr.expression, aliases);
-            break;
-        case 'function_expr':
-        case 'aggregate_expr':
-            for (const arg of expr.args) {
-                collectExpressionAliases(arg, aliases);
-            }
-            break;
-        case 'exists_expr':
-            if (expr.filter) {
-                collectExpressionAliases(expr.filter, aliases);
-            }
-            break;
-        case 'literal_expr':
-        case 'reference_expr':
-        case 'context_property_expr':
-            break;
-    }
-}
-function markAliasAndAncestors(alias, traversePatternMap, target) {
-    var _a;
-    let currentAlias = alias;
-    while (currentAlias && traversePatternMap.has(currentAlias)) {
-        if (target.has(currentAlias)) {
-            return;
-        }
-        target.add(currentAlias);
-        currentAlias = (_a = traversePatternMap.get(currentAlias)) === null || _a === void 0 ? void 0 : _a.from;
-    }
-}
-function collectRequiredTraversalAliases(query, traversePatternMap) {
-    const directAliases = new Set();
-    if (query.where) {
-        collectExpressionAliases(query.where, directAliases);
-    }
-    if (query.orderBy) {
-        for (const item of query.orderBy) {
-            collectExpressionAliases(item.expression, directAliases);
-        }
-    }
-    for (const pattern of traversePatternMap.values()) {
-        if (pattern.filter) {
-            directAliases.add(pattern.to);
-        }
-    }
-    const requiredAliases = new Set();
-    for (const alias of directAliases) {
-        markAliasAndAncestors(alias, traversePatternMap, requiredAliases);
-    }
-    return requiredAliases;
-}
-function buildOptionalTraversalSubtree(alias, traversePatternMap, childOptionalAliasesByParent, propertyTriplesByAlias) {
-    var _a, _b;
-    const pattern = traversePatternMap.get(alias);
-    if (!pattern) {
-        throw new Error(`Missing traverse pattern for alias "${alias}"`);
-    }
-    let subtree = {
-        type: 'bgp',
-        triples: [buildTraverseTriple(pattern)],
-    };
-    for (const propTriple of (_a = propertyTriplesByAlias.get(alias)) !== null && _a !== void 0 ? _a : []) {
-        subtree = wrapOptional(subtree, {
-            type: 'bgp',
-            triples: [propTriple],
-        });
-    }
-    for (const childAlias of (_b = childOptionalAliasesByParent.get(alias)) !== null && _b !== void 0 ? _b : []) {
-        subtree = wrapOptional(subtree, buildOptionalTraversalSubtree(childAlias, traversePatternMap, childOptionalAliasesByParent, propertyTriplesByAlias));
-    }
-    return subtree;
-}
-// ---------------------------------------------------------------------------
-// Variable Registry
-// ---------------------------------------------------------------------------
-/**
- * Maps (alias, property) → SPARQL variable name.
- * Used to deduplicate variables across traverse and property_expr nodes.
- */
-class VariableRegistry {
-    constructor() {
-        this.map = new Map();
-        this.usedVarNames = new Set();
-    }
-    key(alias, property) {
-        return bindingKey(alias, property);
-    }
-    has(alias, property) {
-        return this.map.has(this.key(alias, property));
-    }
-    get(alias, property) {
-        return this.map.get(this.key(alias, property));
-    }
-    set(alias, property, variable) {
-        this.map.set(this.key(alias, property), variable);
-        this.usedVarNames.add(variable);
-    }
-    getOrCreate(alias, property) {
-        const existing = this.get(alias, property);
-        if (existing)
-            return existing;
-        const suffix = propertySuffix(property);
-        let varName = `${sanitizeVarName(alias)}_${suffix}`;
-        // Deduplicate: if varName is already used by a different (alias, property),
-        // append a counter to ensure unique SPARQL variable names
-        let counter = 2;
-        while (this.usedVarNames.has(varName)) {
-            varName = `${sanitizeVarName(alias)}_${suffix}_${counter}`;
-            counter++;
-        }
-        this.set(alias, property, varName);
-        return varName;
-    }
-}
-// ---------------------------------------------------------------------------
-// Aggregate detection
-// ---------------------------------------------------------------------------
-/**
- * Checks whether a SparqlExpression tree contains an aggregate sub-expression.
- * Used to route aggregate-containing filters to HAVING instead of FILTER.
- */
-function containsAggregate(expr) {
-    switch (expr.kind) {
-        case 'aggregate_expr':
-            return true;
-        case 'in_expr':
-            return containsAggregate(expr.value) || expr.list.some(containsAggregate);
-        case 'binary_expr':
-            return containsAggregate(expr.left) || containsAggregate(expr.right);
-        case 'logical_expr':
-            return expr.exprs.some(containsAggregate);
-        case 'not_expr':
-            return containsAggregate(expr.inner);
-        case 'function_expr':
-            return expr.args.some(containsAggregate);
-        default:
-            return false;
-    }
-}
-// ---------------------------------------------------------------------------
-// Select conversion
-// ---------------------------------------------------------------------------
-/**
- * Converts an IRSelectQuery to a SparqlSelectPlan.
- */
-function selectToAlgebra(query, _options) {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
-    const registry = new VariableRegistry();
-    // Promote bindings only when the top-level WHERE would reject rows without
-    // them. This keeps human-like SPARQL for null-rejecting filters without
-    // over-constraining OR cases that can still match through other branches.
-    const requiredPropertyKeys = query.where
-        ? collectRequiredBindingKeys(query.where)
-        : new Set();
-    const requiredPropertyTriples = [];
-    // Track property triples that need to be added as OPTIONAL
-    const optionalPropertyTriples = [];
-    // Track filtered traversals (inline where) — these get their own OPTIONAL blocks
-    const filteredTraverseBlocks = [];
-    // 1. Root shape scan → BGP with type triple
-    if (!(query === null || query === void 0 ? void 0 : query.root)) {
-        throw new Error('selectToAlgebra: query.root is undefined. The query IR is missing its root shape scan. ' +
-            'This usually means the query was built with a null/undefined subject (e.g. getQueryContext returned null).');
-    }
-    const rootAlias = query.root.alias;
-    const shapeUri = query.root.shape;
-    const typeTriple = tripleOf(varTerm(rootAlias), iriTerm(RDF_TYPE), iriTerm(resolveShapeScanIri(shapeUri)));
-    const requiredTriples = [typeTriple];
-    // Track traverse triples (required pattern)
-    const traverseTriples = [];
-    const traversePatternsInOrder = collectTraversePatternsInOrder(query.patterns);
-    const traversePatternMap = new Map(traversePatternsInOrder.map((pattern) => [pattern.to, pattern]));
-    // ── Nested-select inner LIMIT/OFFSET (Option A: single-subject only) ──────
-    // A nested select on a related collection may carry an inner LIMIT/OFFSET.
-    // A plain SPARQL sub-SELECT is uncorrelated, so its LIMIT bounds GLOBALLY.
-    // That only equals per-parent windowing when the outer query targets exactly
-    // ONE root subject — then we inline that subject into the sub-SELECT.
-    const paginatedTraversePatterns = traversePatternsInOrder.filter((p) => typeof p.innerLimit === 'number' ||
-        typeof p.innerOffset === 'number' ||
-        (p.innerOrderBy && p.innerOrderBy.length > 0));
-    const singleSubjectIri = (_a = query.subjectId) !== null && _a !== void 0 ? _a : (query.subjectIds && query.subjectIds.length === 1
-        ? query.subjectIds[0]
-        : undefined);
-    if (paginatedTraversePatterns.length > 0 && !singleSubjectIri) {
-        throw new Error('Inner LIMIT/OFFSET on a nested select is only supported when the outer ' +
-            'query targets a single subject; multi-parent per-group pagination is not ' +
-            'yet implemented.');
-    }
-    // Only root→child traversals can be inlined against the single subject.
-    // A paginated traversal deeper than root→child has a parent collection that is
-    // itself multi-valued (effectively multi-parent), so a sub-SELECT LIMIT there
-    // would bound globally, not per-parent. Reject it loudly rather than silently
-    // dropping the inner limit.
-    const deepPaginated = paginatedTraversePatterns.filter((p) => p.from !== rootAlias);
-    if (deepPaginated.length > 0) {
-        throw new Error('Inner LIMIT/OFFSET on a nested select is only supported on a direct nested ' +
-            'select of the single root subject; pagination on a deeper (grandchild) ' +
-            'collection is multi-parent and not yet implemented.');
-    }
-    const subSelectAliases = new Set(paginatedTraversePatterns.map((p) => p.to));
-    // 2. Process patterns → traverse triples, populate variable registry.
-    //    Skip sub-SELECT-wrapped traversals here — they are emitted separately
-    //    (their child variable is still registered so projection/optionals work).
-    for (const pattern of query.patterns) {
-        processPattern(pattern, registry, traverseTriples, optionalPropertyTriples, filteredTraverseBlocks, subSelectAliases);
-    }
-    // 3. Pre-register filter property references BEFORE processing projections.
-    //    This ensures that property triples needed by inline where filters are
-    //    co-located inside the filtered OPTIONAL block, not in separate OPTIONALs.
-    const filterPropertyTriplesMap = new Map();
-    filteredTraverseBlocks.forEach((block, idx) => {
-        const filterPropertyTriples = [];
-        processExpressionForProperties(block.filter, registry, filterPropertyTriples);
-        filterPropertyTriplesMap.set(idx, filterPropertyTriples);
-    });
-    // 4. Process projection expressions, where clause, orderBy expressions
-    //    to discover any additional property_expr references.
-    //    Properties already registered by inline filters (above) will be skipped.
-    for (const item of query.projection) {
-        processExpressionForProperties(item.expression, registry, optionalPropertyTriples, requiredPropertyTriples, requiredPropertyKeys);
-    }
-    if (query.where) {
-        processExpressionForProperties(query.where, registry, optionalPropertyTriples, requiredPropertyTriples, requiredPropertyKeys);
-    }
-    if (query.orderBy) {
-        for (const orderItem of query.orderBy) {
-            processExpressionForProperties(orderItem.expression, registry, optionalPropertyTriples, requiredPropertyTriples, requiredPropertyKeys);
-        }
-    }
-    const projectedTraversalAliases = new Set();
-    const directProjectionAliases = collectDirectProjectionAliases(query, rootAlias);
-    for (const alias of directProjectionAliases) {
-        markAliasAndAncestors(alias, traversePatternMap, projectedTraversalAliases);
-    }
-    const requiredTraversalAliases = collectRequiredTraversalAliases(query, traversePatternMap);
-    const optionalTraversalAliases = new Set([...projectedTraversalAliases].filter((alias) => {
-        const pattern = traversePatternMap.get(alias);
-        // Lower projection-only traversals into OPTIONAL subtrees regardless of
-        // cardinality, so a parent with an empty relationship is preserved (with
-        // an empty array / null child) instead of being inner-joined away. The
-        // result grouper already collects multiple child bindings into an array.
-        //
-        // Excluded:
-        //  - filtered traversals (`.where(...)`) — the filter makes the child required
-        //  - aliases otherwise required by the query (e.g. used in a top-level filter)
-        //  - paginated traversals — emitted separately as a sub-SELECT (section 5a),
-        //    so lowering them here too would double-emit the traverse triple
-        return !!pattern &&
-            !pattern.filter &&
-            !subSelectAliases.has(alias) &&
-            !requiredTraversalAliases.has(alias);
-    }));
-    const requiredTraverseTriples = traverseTriples.filter((triple) => !(triple.object.kind === 'variable' &&
-        optionalTraversalAliases.has(triple.object.name)));
-    const nestedOptionalPropertyTriplesByAlias = new Map();
-    const topLevelOptionalPropertyTriples = [];
-    // Property triples whose subject is a sub-SELECT child alias must be nested
-    // INSIDE the sub-SELECT's OPTIONAL block (keyed by alias), so that ?childVar
-    // stays scoped — otherwise an empty window leaves ?childVar unbound and the
-    // outer property OPTIONAL leaks across the whole graph.
-    const subSelectChildPropertyTriplesByAlias = new Map();
-    // Same scoping rule for filtered traversals (`.where(...)`): anything anchored
-    // on the filtered alias must live inside its filtered OPTIONAL block — when
-    // the filter matches nothing, the alias is unbound and a top-level OPTIONAL
-    // would range over the whole graph.
-    const filteredTraverseAliases = new Set(filteredTraverseBlocks.map((b) => b.toAlias));
-    const filteredChildPropertyTriplesByAlias = new Map();
-    for (const propTriple of optionalPropertyTriples) {
-        if (propTriple.subject.kind === 'variable' &&
-            subSelectAliases.has(propTriple.subject.name)) {
-            const triples = (_b = subSelectChildPropertyTriplesByAlias.get(propTriple.subject.name)) !== null && _b !== void 0 ? _b : [];
-            triples.push(propTriple);
-            subSelectChildPropertyTriplesByAlias.set(propTriple.subject.name, triples);
-        }
-        else if (propTriple.subject.kind === 'variable' &&
-            filteredTraverseAliases.has(propTriple.subject.name)) {
-            const triples = (_c = filteredChildPropertyTriplesByAlias.get(propTriple.subject.name)) !== null && _c !== void 0 ? _c : [];
-            triples.push(propTriple);
-            filteredChildPropertyTriplesByAlias.set(propTriple.subject.name, triples);
-        }
-        else if (propTriple.subject.kind === 'variable' &&
-            optionalTraversalAliases.has(propTriple.subject.name)) {
-            const triples = (_d = nestedOptionalPropertyTriplesByAlias.get(propTriple.subject.name)) !== null && _d !== void 0 ? _d : [];
-            triples.push(propTriple);
-            nestedOptionalPropertyTriplesByAlias.set(propTriple.subject.name, triples);
-        }
-        else {
-            topLevelOptionalPropertyTriples.push(propTriple);
-        }
-    }
-    const childOptionalAliasesByParent = new Map();
-    for (const pattern of traversePatternsInOrder) {
-        if (!optionalTraversalAliases.has(pattern.to))
-            continue;
-        const siblings = (_e = childOptionalAliasesByParent.get(pattern.from)) !== null && _e !== void 0 ? _e : [];
-        siblings.push(pattern.to);
-        childOptionalAliasesByParent.set(pattern.from, siblings);
-    }
-    const rootOptionalTraversalAliases = traversePatternsInOrder
-        .filter((pattern) => optionalTraversalAliases.has(pattern.to) &&
-        !optionalTraversalAliases.has(pattern.from) &&
-        // Children of a filtered traversal nest inside its filtered block (5b)
-        !filteredTraverseAliases.has(pattern.from))
-        .map((pattern) => pattern.to);
-    // 5. Build the algebra tree
-    //    - Start with the required BGP (type triple + traverse triples)
-    //    - Wrap each optional property triple in a LeftJoin
-    const requiredBgp = {
-        type: 'bgp',
-        triples: [...requiredTriples, ...requiredTraverseTriples, ...requiredPropertyTriples],
-    };
-    let algebra = requiredBgp;
-    // 5a. Nested-select inner LIMIT/OFFSET → sub-SELECT (single-subject only).
-    //     Wrap each root→child paginated traversal in a sub-SELECT that inlines
-    //     the single subject, projecting only the child variable. The child's own
-    //     property triples stay OUTSIDE (as OPTIONALs), joined on the child var —
-    //     so the flat-row structure and result mapping are unchanged.
-    // Every pattern here is a root→child paginated traversal (the deep-pagination
-    // guard above rejected anything else), so each maps 1:1 to a sub-SELECT.
-    for (const pattern of paginatedTraversePatterns) {
-        const predicate = buildPredicateTerm(pattern);
-        const innerTriple = tripleOf(iriTerm(singleSubjectIri), predicate, varTerm(pattern.to));
-        // Default ORDER BY ?childVar for a deterministic window, unless the nested
-        // select supplied its own ordering. When it did, each ordered property must
-        // also be bound inside the sub-SELECT so the ORDER BY variable resolves.
-        let orderBy;
-        let innerNode = { type: 'bgp', triples: [innerTriple] };
-        if (pattern.innerOrderBy && pattern.innerOrderBy.length > 0) {
-            orderBy = pattern.innerOrderBy.map((o) => {
-                const orderVar = registry.getOrCreate(pattern.to, o.property);
-                innerNode = joinNodes(innerNode, {
-                    type: 'bgp',
-                    triples: [tripleOf(varTerm(pattern.to), resolvePropertyPredicateTerm(o.property), varTerm(orderVar))],
-                });
-                return {
-                    expression: { kind: 'variable_expr', name: orderVar },
-                    direction: o.direction,
-                };
-            });
-        }
-        else {
-            orderBy = [{
-                    expression: { kind: 'variable_expr', name: pattern.to },
-                    direction: 'ASC',
-                }];
-        }
-        const subSelect = Object.assign(Object.assign({ type: 'subselect', projection: [pattern.to], inner: innerNode, orderBy }, (typeof pattern.innerLimit === 'number' ? { limit: pattern.innerLimit } : {})), (typeof pattern.innerOffset === 'number' ? { offset: pattern.innerOffset } : {}));
-        // Nest the child's own property triples (e.g. ?a1 <name> ?a1_name) INSIDE
-        // this block, each as its own OPTIONAL, so they only bind when the window
-        // produced a ?childVar. This keeps the flat-row projection unchanged.
-        let childBlock = subSelect;
-        for (const propTriple of (_f = subSelectChildPropertyTriplesByAlias.get(pattern.to)) !== null && _f !== void 0 ? _f : []) {
-            childBlock = wrapOptional(childBlock, { type: 'bgp', triples: [propTriple] });
-        }
-        // OPTIONAL so a parent with an empty (or fully-windowed-out) child set is
-        // still returned — the sub-SELECT yields no ?a1 binding, but the parent row
-        // survives (mirrors the plain nested-traverse OPTIONAL behaviour).
-        algebra = wrapOptional(algebra, childBlock);
-    }
-    // 5b. Build filtered OPTIONAL blocks for inline where traversals.
-    //     Each block contains: traverse triple + OPTIONAL property triples + FILTER.
-    //     Filter property triples are nested as OPTIONALs so that OR filters work
-    //     even when some entities lack certain properties.
-    // First pass: build each filtered block's inner group and filter expression.
-    const filteredBlockInners = [];
-    const filteredBlockExprs = [];
-    const filteredBlockIdxByAlias = new Map(filteredTraverseBlocks.map((block, i) => [block.toAlias, i]));
-    for (let i = 0; i < filteredTraverseBlocks.length; i++) {
-        const block = filteredTraverseBlocks[i];
-        const filterPropertyTriples = filterPropertyTriplesMap.get(i) || [];
-        const filterExpr = convertExpression(block.filter, registry, filterPropertyTriples);
-        // Start with the traverse triple as the required BGP
-        let blockInner = { type: 'bgp', triples: [block.traverseTriple] };
-        // Wrap each filter property triple in its own nested OPTIONAL
-        for (const propTriple of filterPropertyTriples) {
-            blockInner = wrapOptional(blockInner, { type: 'bgp', triples: [propTriple] });
-        }
-        // Projected property triples on the filtered alias that aren't part of the
-        // filter (e.g. `.where(name=...).select(pp => [pp.hobby])`)
-        for (const propTriple of (_g = filteredChildPropertyTriplesByAlias.get(block.toAlias)) !== null && _g !== void 0 ? _g : []) {
-            blockInner = wrapOptional(blockInner, { type: 'bgp', triples: [propTriple] });
-        }
-        // Optional child traversal subtrees (nested sub-selects below the filtered
-        // alias) — kept inside the block so an empty filter match leaves them unbound
-        for (const childAlias of (_h = childOptionalAliasesByParent.get(block.toAlias)) !== null && _h !== void 0 ? _h : []) {
-            blockInner = wrapOptional(blockInner, buildOptionalTraversalSubtree(childAlias, traversePatternMap, childOptionalAliasesByParent, nestedOptionalPropertyTriplesByAlias));
-        }
-        filteredBlockInners.push(blockInner);
-        filteredBlockExprs.push(filterExpr);
-    }
-    // Second pass, children first (blocks are created parent-before-child):
-    // finish each block and either nest it inside its parent's filtered block —
-    // a filtered sub-select inside another filtered sub-select must stay scoped
-    // to the parent alias, or an empty parent match leaves the alias unbound and
-    // the block cross-products over the whole graph — or attach it at top level.
-    const rootFilteredBlocks = [];
-    for (let i = filteredTraverseBlocks.length - 1; i >= 0; i--) {
-        const block = filteredTraverseBlocks[i];
-        const finished = {
-            type: 'filter',
-            expression: filteredBlockExprs[i],
-            inner: filteredBlockInners[i],
-        };
-        const subject = block.traverseTriple.subject;
-        const parentIdx = subject.kind === 'variable'
-            ? filteredBlockIdxByAlias.get(subject.name)
-            : undefined;
-        if (parentIdx !== undefined && parentIdx !== i) {
-            filteredBlockInners[parentIdx] = wrapOptional(filteredBlockInners[parentIdx], finished);
-        }
-        else {
-            rootFilteredBlocks.unshift(finished);
-        }
-    }
-    for (const filteredBlock of rootFilteredBlocks) {
-        algebra = wrapOptional(algebra, filteredBlock);
-    }
-    for (const alias of rootOptionalTraversalAliases) {
-        algebra = wrapOptional(algebra, buildOptionalTraversalSubtree(alias, traversePatternMap, childOptionalAliasesByParent, nestedOptionalPropertyTriplesByAlias));
-    }
-    // Wrap each optional property triple in its own OPTIONAL (LeftJoin)
-    for (const propTriple of topLevelOptionalPropertyTriples) {
-        algebra = wrapOptional(algebra, {
-            type: 'bgp',
-            triples: [propTriple],
-        });
-    }
-    // 5. Where clause → Filter wrapping (or HAVING if aggregate-containing)
-    let havingExpr;
-    if (query.where) {
-        const filterExpr = convertExpression(query.where, registry, optionalPropertyTriples);
-        if (containsAggregate(filterExpr)) {
-            havingExpr = filterExpr;
-        }
-        else {
-            algebra = {
-                type: 'filter',
-                expression: filterExpr,
-                inner: algebra,
-            };
-        }
-    }
-    // 5b. MINUS patterns — wrap algebra in SparqlMinus for each minus pattern
-    for (const pattern of query.patterns) {
-        if (pattern.kind === 'minus') {
-            let minusAlgebra = convertExistsPattern(pattern.pattern, registry);
-            if (pattern.filter) {
-                const minusPropertyTriples = [];
-                processExpressionForProperties(pattern.filter, registry, minusPropertyTriples);
-                // Add property triples into the MINUS block
-                if (minusPropertyTriples.length > 0) {
-                    minusAlgebra = joinNodes(minusAlgebra, { type: 'bgp', triples: minusPropertyTriples });
-                }
-                const filterExpr = convertExpression(pattern.filter, registry, minusPropertyTriples);
-                minusAlgebra = { type: 'filter', expression: filterExpr, inner: minusAlgebra };
-            }
-            algebra = { type: 'minus', left: algebra, right: minusAlgebra };
-        }
-    }
-    // 6. SubjectId → Filter / SubjectIds → VALUES
-    if (query.subjectIds && query.subjectIds.length > 0) {
-        // Multiple subjects: use VALUES clause for efficient filtering
-        algebra = joinNodes({ type: 'values', variable: rootAlias, iris: query.subjectIds }, algebra);
-    }
-    else if (query.subjectId) {
-        const subjectFilter = {
-            kind: 'binary_expr',
-            op: '=',
-            left: { kind: 'variable_expr', name: rootAlias },
-            right: { kind: 'iri_expr', value: query.subjectId },
-        };
-        algebra = {
-            type: 'filter',
-            expression: subjectFilter,
-            inner: algebra,
-        };
-    }
-    // 7. Build projection
-    const projection = [];
-    const aggregates = [];
-    let hasAggregates = false;
-    // Always include root alias as first projection variable
-    projection.push({ kind: 'variable', name: rootAlias });
-    // Collect traversal aliases upfront to detect aggregate alias collisions
-    const traversalAliasSet = new Set(collectTraversalAliases(query.patterns));
-    // Track traversal aliases consumed by aggregate renames (should not be
-    // re-projected as plain variables, which would alter GROUP BY semantics)
-    const aggregateRenamedAliases = new Set();
-    for (const item of query.projection) {
-        const sparqlExpr = convertExpression(item.expression, registry, optionalPropertyTriples);
-        if (sparqlExpr.kind === 'aggregate_expr') {
-            hasAggregates = true;
-            // Avoid collision: if aggregate alias matches a traversal alias,
-            // rename it so SPARQL doesn't produce duplicate variable bindings
-            let aggAlias = item.alias;
-            if (traversalAliasSet.has(aggAlias)) {
-                aggregateRenamedAliases.add(aggAlias);
-                aggAlias = `${aggAlias}_agg`;
-                // Update resultMap so result mapping uses the renamed alias
-                for (const rm of query.resultMap) {
-                    if (rm.alias === item.alias)
-                        rm.alias = aggAlias;
-                }
-            }
-            projection.push({
-                kind: 'aggregate',
-                expression: sparqlExpr,
-                alias: aggAlias,
-            });
-            aggregates.push({
-                variable: aggAlias,
-                aggregate: sparqlExpr,
-            });
-        }
-        else {
-            // For property_expr, the variable is the resolved name from registry
-            const varName = resolveExpressionVariable(item.expression, registry);
-            if (varName && varName !== rootAlias) {
-                projection.push({ kind: 'variable', name: varName });
-            }
-            else if (!varName) {
-                // Non-variable expression (binary_expr, function_expr, etc.)
-                // → project as (expr AS ?alias)
-                let exprAlias = item.alias;
-                if (traversalAliasSet.has(exprAlias)) {
-                    // The output alias collides with a traversal target variable — e.g. a
-                    // computed expression over a traversed path lowers to
-                    // (UCASE(?a1_name) AS ?a1), and ?a1 is already bound by the traverse
-                    // triple. Rename the output so SPARQL doesn't reuse an in-scope var.
-                    exprAlias = `${exprAlias}_expr`;
-                    for (const rm of query.resultMap) {
-                        if (rm.alias === item.alias)
-                            rm.alias = exprAlias;
-                    }
-                }
-                projection.push({ kind: 'expression', expression: sparqlExpr, alias: exprAlias });
-            }
-        }
-    }
-    // 7b. Include traversal aliases needed for result grouping
-    //     When nested results are projected (e.g. p.friends.name), the result
-    //     mapping needs the traversal alias variable (?a1) in the bindings to
-    //     group nested rows by entity. Without this, mapNestedRows() can't
-    //     identify which nested fields belong to which traversed entity.
-    const projectedNames = new Set();
-    for (const p of projection) {
-        if (p.kind === 'variable')
-            projectedNames.add(p.name);
-        else if (p.kind === 'aggregate' || p.kind === 'expression')
-            projectedNames.add(p.alias);
-    }
-    for (const alias of collectTraversalAliases(query.patterns)) {
-        if (!projectedNames.has(alias) && !aggregateRenamedAliases.has(alias)) {
-            projection.push({ kind: 'variable', name: alias });
-            projectedNames.add(alias);
-        }
-    }
-    // 8. GROUP BY inference
-    let groupBy;
-    if (havingExpr) {
-        hasAggregates = true;
-    }
-    if (hasAggregates) {
-        // All non-aggregate projected variables become GROUP BY targets
-        groupBy = projection
-            .filter((p) => p.kind === 'variable')
-            .map((p) => p.name);
-    }
-    // 9. OrderBy
-    let orderBy;
-    if (query.orderBy) {
-        orderBy = query.orderBy.map((item) => ({
-            expression: convertExpression(item.expression, registry, optionalPropertyTriples),
-            direction: item.direction,
-        }));
-    }
-    // `.one()` lowers to limit=1 + singleResult, but LIMIT bounds ROWS, not
-    // entities. When the query yields multiple rows per root entity (traversals
-    // or plural properties), a row-level LIMIT would truncate the entity's own
-    // nested data — omit it and let the result mapper pick the single entity.
-    const multiRowPerEntity = query.patterns.some((p) => p.kind === 'traverse') ||
-        query.projection.some((item) => item.expression.kind === 'property_expr' &&
-            !(typeof item.expression.maxCount === 'number' && item.expression.maxCount <= 1));
-    const limit = query.singleResult && query.limit === 1 && multiRowPerEntity
-        ? undefined
-        : query.limit;
-    return {
-        type: 'select',
-        algebra,
-        projection,
-        distinct: !hasAggregates ? true : undefined,
-        orderBy,
-        limit,
-        offset: query.offset,
-        groupBy,
-        having: havingExpr,
-        aggregates: aggregates.length > 0 ? aggregates : undefined,
-    };
-}
-// ---------------------------------------------------------------------------
-// Pattern processing
-// ---------------------------------------------------------------------------
-function processPattern(pattern, registry, traverseTriples, optionalPropertyTriples, filteredTraverseBlocks, subSelectAliases) {
-    switch (pattern.kind) {
-        case 'shape_scan':
-            // Additional shape scans (non-root) are handled as type triples
-            // but this case is rare — root is handled separately
-            break;
-        case 'traverse': {
-            // Register the traverse variable: (from, property) → to
-            registry.set(pattern.from, pattern.property, pattern.to);
-            // Traversals wrapped in a sub-SELECT (inner LIMIT/OFFSET) are emitted
-            // separately — don't add their triple to the required BGP here.
-            if (subSelectAliases === null || subSelectAliases === void 0 ? void 0 : subSelectAliases.has(pattern.to)) {
-                break;
-            }
-            // Add traverse triple to required pattern (or filtered block if inline where)
-            const triple = buildTraverseTriple(pattern);
-            if (pattern.filter && filteredTraverseBlocks) {
-                filteredTraverseBlocks.push({
-                    traverseTriple: triple,
-                    filter: pattern.filter,
-                    toAlias: pattern.to,
-                });
-            }
-            else {
-                traverseTriples.push(triple);
-            }
-            break;
-        }
-        case 'join': {
-            for (const sub of pattern.patterns) {
-                processPattern(sub, registry, traverseTriples, optionalPropertyTriples, filteredTraverseBlocks, subSelectAliases);
-            }
-            break;
-        }
-        case 'optional': {
-            // Optional patterns — process inner patterns but keep them optional
-            processPattern(pattern.pattern, registry, traverseTriples, optionalPropertyTriples, filteredTraverseBlocks, subSelectAliases);
-            break;
-        }
-        case 'union': {
-            for (const branch of pattern.branches) {
-                processPattern(branch, registry, traverseTriples, optionalPropertyTriples, filteredTraverseBlocks, subSelectAliases);
-            }
-            break;
-        }
-        case 'exists': {
-            processPattern(pattern.pattern, registry, traverseTriples, optionalPropertyTriples, filteredTraverseBlocks, subSelectAliases);
-            break;
-        }
-        case 'minus': {
-            // MINUS patterns are handled separately in selectToAlgebra — skip in processPattern.
-            break;
-        }
-    }
-}
-// ---------------------------------------------------------------------------
-// Expression processing — discover property_expr references
-// ---------------------------------------------------------------------------
-function processExpressionForProperties(expr, registry, optionalPropertyTriples, requiredPropertyTriples = [], requiredPropertyKeys = new Set()) {
-    switch (expr.kind) {
-        case 'property_expr': {
-            if (!registry.has(expr.sourceAlias, expr.property)) {
-                const varName = registry.getOrCreate(expr.sourceAlias, expr.property);
-                const predicate = buildPredicateTerm(expr);
-                const triple = tripleOf(varTerm(expr.sourceAlias), predicate, varTerm(varName));
-                const triples = requiredPropertyKeys.has(bindingKey(expr.sourceAlias, expr.property))
-                    ? requiredPropertyTriples
-                    : optionalPropertyTriples;
-                triples.push(triple);
-            }
-            break;
-        }
-        case 'binary_expr':
-            processExpressionForProperties(expr.left, registry, optionalPropertyTriples, requiredPropertyTriples, requiredPropertyKeys);
-            processExpressionForProperties(expr.right, registry, optionalPropertyTriples, requiredPropertyTriples, requiredPropertyKeys);
-            break;
-        case 'in_expr':
-            // The tested value binds a property; list elements are constants.
-            processExpressionForProperties(expr.value, registry, optionalPropertyTriples, requiredPropertyTriples, requiredPropertyKeys);
-            break;
-        case 'logical_expr':
-            for (const sub of expr.expressions) {
-                processExpressionForProperties(sub, registry, optionalPropertyTriples, requiredPropertyTriples, requiredPropertyKeys);
-            }
-            break;
-        case 'not_expr':
-            processExpressionForProperties(expr.expression, registry, optionalPropertyTriples, requiredPropertyTriples, requiredPropertyKeys);
-            break;
-        case 'function_expr':
-            for (const arg of expr.args) {
-                processExpressionForProperties(arg, registry, optionalPropertyTriples, requiredPropertyTriples, requiredPropertyKeys);
-            }
-            break;
-        case 'aggregate_expr':
-            for (const arg of expr.args) {
-                processExpressionForProperties(arg, registry, optionalPropertyTriples, requiredPropertyTriples, requiredPropertyKeys);
-            }
-            break;
-        case 'exists_expr':
-            // exists_expr filter properties belong INSIDE the EXISTS block, not in
-            // the outer scope. Do NOT register them here — convertExpression's
-            // exists_expr handler will collect and emit them locally.
-            break;
-        case 'context_property_expr': {
-            // Context entity property — emit a triple with fixed IRI as subject.
-            // Use raw IRI as registry key to avoid collision between IRIs that
-            // sanitize to the same string (e.g. ctx-1 vs ctx_1).
-            const contextIri = resolvedContextIri(expr.contextIri, expr.contextName);
-            const ctxKey = contextAliasKey(contextIri);
-            if (!registry.has(ctxKey, expr.property)) {
-                const varName = registry.getOrCreate(ctxKey, expr.property);
-                const triple = tripleOf(iriTerm(contextIri), resolvePropertyPredicateTerm(expr.property), varTerm(varName));
-                const triples = requiredPropertyKeys.has(bindingKey(ctxKey, expr.property))
-                    ? requiredPropertyTriples
-                    : optionalPropertyTriples;
-                triples.push(triple);
-            }
-            break;
-        }
-        case 'literal_expr':
-        case 'reference_expr':
-        case 'alias_expr':
-            // No property references to discover
-            break;
-    }
-}
-/**
- * Compute which bindings are mandatory for a top-level FILTER to keep a row.
- * AND makes either side required; OR only keeps bindings required by every branch.
- */
-function collectRequiredBindingKeys(expr) {
-    switch (expr.kind) {
-        case 'property_expr':
-            return new Set([bindingKey(expr.sourceAlias, expr.property)]);
-        case 'context_property_expr':
-            return new Set([bindingKey(contextAliasKey(resolvedContextIri(expr.contextIri, expr.contextName)), expr.property)]);
-        case 'in_expr':
-            // The tested value must be bound; list elements are constants.
-            return collectRequiredBindingKeys(expr.value);
-        case 'binary_expr':
-            return mergeKeySets(collectRequiredBindingKeys(expr.left), collectRequiredBindingKeys(expr.right));
-        case 'function_expr': {
-            const fn = expr.name.toUpperCase();
-            // BOUND explicitly tests boundness — forcing its argument into a
-            // required (inner-join) pattern would make !BOUND unsatisfiable.
-            // COALESCE is unbound-tolerant by design — requiring its arguments
-            // would make the fallback unreachable.
-            if (fn === 'BOUND' || fn === 'COALESCE') {
-                return new Set();
-            }
-            // IF: an unbound variable in the condition errors the row out either
-            // way, so the condition may keep its requirements — but the then/else
-            // branches must stay optional (the untaken branch may reference a
-            // property the entity doesn't have).
-            if (fn === 'IF') {
-                return expr.args.length > 0
-                    ? collectRequiredBindingKeys(expr.args[0])
-                    : new Set();
-            }
-            return mergeKeySets(...expr.args.map((arg) => collectRequiredBindingKeys(arg)));
-        }
-        case 'not_expr':
-            return collectRequiredBindingKeys(expr.expression);
-        case 'logical_expr': {
-            const childSets = expr.expressions.map((sub) => collectRequiredBindingKeys(sub));
-            if (expr.operator === 'and') {
-                return mergeKeySets(...childSets);
-            }
-            return intersectKeySets(childSets);
-        }
-        case 'aggregate_expr':
-        case 'exists_expr':
-        case 'literal_expr':
-        case 'reference_expr':
-        case 'alias_expr':
-            return new Set();
-    }
-}
-// ---------------------------------------------------------------------------
-// Expression conversion
-// ---------------------------------------------------------------------------
-function convertExpression(expr, registry, optionalPropertyTriples) {
-    switch (expr.kind) {
-        case 'literal_expr': {
-            const value = expr.value;
-            if (value === null || value === undefined) {
-                return { kind: 'literal_expr', value: '' };
-            }
-            if (typeof value === 'boolean') {
-                return {
-                    kind: 'literal_expr',
-                    value: String(value),
-                    datatype: XSD_BOOLEAN,
-                };
-            }
-            if (typeof value === 'number') {
-                if (Number.isInteger(value)) {
-                    return {
-                        kind: 'literal_expr',
-                        value: String(value),
-                        datatype: XSD_INTEGER,
-                    };
-                }
-                return {
-                    kind: 'literal_expr',
-                    value: String(value),
-                    datatype: XSD_DOUBLE,
-                };
-            }
-            return { kind: 'literal_expr', value: String(value) };
-        }
-        case 'reference_expr':
-            return { kind: 'iri_expr', value: resolvedContextIri(expr.value, expr.contextName) };
-        case 'alias_expr':
-            return { kind: 'variable_expr', name: expr.alias };
-        case 'context_property_expr': {
-            const ctxKey = `__ctx__${resolvedContextIri(expr.contextIri, expr.contextName)}`;
-            const ctxVarName = registry.getOrCreate(ctxKey, expr.property);
-            return { kind: 'variable_expr', name: ctxVarName };
-        }
-        case 'property_expr': {
-            const varName = registry.getOrCreate(expr.sourceAlias, expr.property);
-            return { kind: 'variable_expr', name: varName };
-        }
-        case 'in_expr':
-            return {
-                kind: 'in_expr',
-                negated: expr.negated,
-                value: convertExpression(expr.value, registry, optionalPropertyTriples),
-                list: expr.source.list.map((e) => convertExpression(e, registry, optionalPropertyTriples)),
-            };
-        case 'binary_expr':
-            return {
-                kind: 'binary_expr',
-                op: expr.operator,
-                left: convertExpression(expr.left, registry, optionalPropertyTriples),
-                right: convertExpression(expr.right, registry, optionalPropertyTriples),
-            };
-        case 'logical_expr':
-            return {
-                kind: 'logical_expr',
-                op: expr.operator,
-                exprs: expr.expressions.map((e) => convertExpression(e, registry, optionalPropertyTriples)),
-            };
-        case 'not_expr':
-            return {
-                kind: 'not_expr',
-                inner: convertExpression(expr.expression, registry, optionalPropertyTriples),
-            };
-        case 'function_expr':
-            return {
-                kind: 'function_expr',
-                name: expr.name,
-                args: expr.args.map((a) => convertExpression(a, registry, optionalPropertyTriples)),
-            };
-        case 'aggregate_expr':
-            return {
-                kind: 'aggregate_expr',
-                name: expr.name,
-                args: expr.args.map((a) => convertExpression(a, registry, optionalPropertyTriples)),
-            };
-        case 'exists_expr': {
-            // Convert exists expression with inner pattern + filter.
-            // Filter property triples must live INSIDE the EXISTS block
-            // (not in the outer scope), so we collect them locally.
-            let innerAlgebra = convertExistsPattern(expr.pattern, registry);
-            if (expr.filter) {
-                // First, discover and register filter property references,
-                // collecting their triples into a local array (NOT the outer scope).
-                const existsPropertyTriples = [];
-                processExpressionForProperties(expr.filter, registry, existsPropertyTriples);
-                // Now convert the filter expression (variables are registered above).
-                const filterExpr = convertExpression(expr.filter, registry, existsPropertyTriples);
-                // Add filter property triples inside the EXISTS
-                for (const propTriple of existsPropertyTriples) {
-                    innerAlgebra = joinNodes(innerAlgebra, { type: 'bgp', triples: [propTriple] });
-                }
-                // Wrap the inner pattern with a filter
-                const filteredInner = {
-                    type: 'filter',
-                    expression: filterExpr,
-                    inner: innerAlgebra,
-                };
-                return {
-                    kind: 'exists_expr',
-                    pattern: filteredInner,
-                    negated: false,
-                };
-            }
-            return {
-                kind: 'exists_expr',
-                pattern: innerAlgebra,
-                negated: false,
-            };
-        }
-        default:
-            throw new Error(`Unknown IR expression kind: ${expr.kind}`);
-    }
-}
-/**
- * Convert an exists pattern (from exists_expr) into an algebra node.
- * Recursively handles all IR graph pattern kinds.
- */
-function convertExistsPattern(pattern, registry) {
-    switch (pattern.kind) {
-        case 'traverse': {
-            const existsPredicate = buildPredicateTerm(pattern);
-            const triple = tripleOf(varTerm(pattern.from), existsPredicate, varTerm(pattern.to));
-            return { type: 'bgp', triples: [triple] };
-        }
-        case 'join': {
-            let result = null;
-            for (const sub of pattern.patterns) {
-                const subNode = convertExistsPattern(sub, registry);
-                result = result ? joinNodes(result, subNode) : subNode;
-            }
-            return result || { type: 'bgp', triples: [] };
-        }
-        case 'shape_scan': {
-            return {
-                type: 'bgp',
-                triples: [
-                    tripleOf(varTerm(pattern.alias), iriTerm(RDF_TYPE), iriTerm(resolveShapeScanIri(pattern.shape))),
-                ],
-            };
-        }
-        case 'optional': {
-            const inner = convertExistsPattern(pattern.pattern, registry);
-            return wrapOptional({ type: 'bgp', triples: [] }, inner);
-        }
-        case 'union': {
-            let result = null;
-            for (const branch of pattern.branches) {
-                const branchNode = convertExistsPattern(branch, registry);
-                if (!result) {
-                    result = branchNode;
-                }
-                else {
-                    result = { type: 'union', left: result, right: branchNode };
-                }
-            }
-            return result || { type: 'bgp', triples: [] };
-        }
-        case 'exists': {
-            return convertExistsPattern(pattern.pattern, registry);
-        }
-        case 'minus': {
-            return convertExistsPattern(pattern.pattern, registry);
-        }
-        default:
-            throw new Error(`Unsupported pattern kind in EXISTS: ${pattern.kind}`);
-    }
-}
-/**
- * Resolve what variable name an IR expression ultimately refers to.
- */
-function resolveExpressionVariable(expr, registry) {
-    switch (expr.kind) {
-        case 'alias_expr':
-            return expr.alias;
-        case 'property_expr':
-            return registry.getOrCreate(expr.sourceAlias, expr.property);
-        default:
-            return null;
-    }
-}
-// ---------------------------------------------------------------------------
-// Mutation conversions
-// ---------------------------------------------------------------------------
-/**
- * Convert a field value to one or more SparqlTerm objects for triple objects.
- */
-function fieldValueToTerms(value, options) {
-    if (value === null || value === undefined) {
-        return [];
-    }
-    if (typeof value === 'string') {
-        return [literalTerm(value)];
-    }
-    if (typeof value === 'number') {
-        if (Number.isInteger(value)) {
-            return [literalTerm(String(value), XSD_INTEGER)];
-        }
-        return [literalTerm(String(value), XSD_DOUBLE)];
-    }
-    if (typeof value === 'boolean') {
-        return [literalTerm(String(value), XSD_BOOLEAN)];
-    }
-    if (value instanceof Date) {
-        return [literalTerm(value.toISOString(), XSD_DATETIME)];
-    }
-    // Computed/expression value in create: create lowers to INSERT DATA (ground
-    // triples, no WHERE), so an expression can't be evaluated here. Fail loudly
-    // instead of silently emitting no triple (report 021 §3, G4).
-    if (value &&
-        typeof value === 'object' &&
-        (isIRExpression(value) || 'ir' in value)) {
-        throw new Error('Computed/expression values are not supported in create (INSERT DATA has no WHERE clause to evaluate them). Use a literal value, or use update.');
-    }
-    // NodeReferenceValue
-    if (typeof value === 'object' && 'id' in value && !('shape' in value) && !('fields' in value)) {
-        return [iriTerm(value.id)];
-    }
-    // IRNodeData — should not produce a term directly (handled by nested create)
-    if (typeof value === 'object' && 'shape' in value && 'fields' in value) {
-        return []; // Handled separately
-    }
-    // Array
-    if (Array.isArray(value)) {
-        const terms = [];
-        for (const item of value) {
-            terms.push(...fieldValueToTerms(item, options));
-        }
-        return terms;
-    }
-    return [];
-}
-/**
- * Recursively generate triples for an IRNodeData (used in create and nested creates).
- * Returns the URI used for this node and all generated triples.
- */
-function generateNodeDataTriples(data, options) {
-    const uri = data.id || (0, sparqlUtils_js_1.generateEntityUri)(data.shape, options);
-    const triples = [];
-    const subjectTerm = iriTerm(uri);
-    // Type triple — resolve the SHACL NodeShape id in the IR to the ontology
-    // targetClass URI (sibling of PR #77's SELECT-side resolveShapeScanIri).
-    // Mutations were not covered by #77; see mutation-uri-fidelity.test.ts.
-    triples.push(tripleOf(subjectTerm, iriTerm(RDF_TYPE), iriTerm(resolveShapeScanIri(data.shape))));
-    // Field triples
-    for (const field of data.fields) {
-        // Resolve the SHACL PropertyShape id to its declared `path` URI.
-        const propertyTerm = resolvePropertyPredicateTerm(field.property);
-        if (field.value === null || field.value === undefined) {
-            continue;
-        }
-        // Handle arrays (including mixed arrays of references and nested creates)
-        if (Array.isArray(field.value)) {
-            for (const item of field.value) {
-                if (item && typeof item === 'object' && 'shape' in item && 'fields' in item) {
-                    // Nested create
-                    const nested = generateNodeDataTriples(item, options);
-                    triples.push(tripleOf(subjectTerm, propertyTerm, iriTerm(nested.uri)));
-                    triples.push(...nested.triples);
-                }
-                else {
-                    const terms = fieldValueToTerms(item, options);
-                    for (const term of terms) {
-                        triples.push(tripleOf(subjectTerm, propertyTerm, term));
-                    }
-                }
-            }
-            continue;
-        }
-        // Handle nested IRNodeData
-        if (typeof field.value === 'object' && 'shape' in field.value && 'fields' in field.value) {
-            const nested = generateNodeDataTriples(field.value, options);
-            triples.push(tripleOf(subjectTerm, propertyTerm, iriTerm(nested.uri)));
-            triples.push(...nested.triples);
-            continue;
-        }
-        // Simple values
-        const terms = fieldValueToTerms(field.value, options);
-        for (const term of terms) {
-            triples.push(tripleOf(subjectTerm, propertyTerm, term));
-        }
-    }
-    return { uri, triples };
-}
-/**
- * Converts an IRCreateMutation to a SparqlInsertDataPlan.
- */
-function createToAlgebra(query, options) {
-    const { triples } = generateNodeDataTriples(query.data, options);
-    return {
-        type: 'insert_data',
-        triples,
-    };
-}
-// ---------------------------------------------------------------------------
-// Shared update field processing
-// ---------------------------------------------------------------------------
-/**
- * Processes IRNodeData fields into DELETE/INSERT/WHERE triples.
- * Shared between updateToAlgebra (IRI subject) and updateWhereToAlgebra (variable subject).
- */
-function processUpdateFields(data, subjectTerm, options) {
-    const deletePatterns = [];
-    const insertPatterns = [];
-    const oldValueTriples = [];
-    const extends_ = [];
-    // Owned-subtree cascade: replacing a `contains` property must also
-    // delete the old object's owned subtree, not just the one-hop edge.
-    const { containsPreds: updContainsPreds } = collectContainment();
-    const containsOldVars = [];
-    const cascadeOptionals = [];
-    for (const field of data.fields) {
-        const propertyTerm = resolvePropertyPredicateTerm(field.property);
-        const suffix = propertySuffix(field.property);
-        const isContainsField = propertyTerm.kind === 'iri' && updContainsPreds.includes(propertyTerm.value);
-        // Check for set modification ({add, remove})
-        if (field.value &&
-            typeof field.value === 'object' &&
-            !Array.isArray(field.value) &&
-            !(field.value instanceof Date) &&
-            !('id' in field.value) &&
-            !('shape' in field.value) &&
-            ('add' in field.value || 'remove' in field.value)) {
-            const setMod = field.value;
-            if (setMod.remove) {
-                setMod.remove.forEach((removeItem, ri) => {
-                    const removeTerm = iriTerm(removeItem.id);
-                    deletePatterns.push(tripleOf(subjectTerm, propertyTerm, removeTerm));
-                    oldValueTriples.push(tripleOf(subjectTerm, propertyTerm, removeTerm));
-                    // For a `contains` set, removing a value also removes its owned subtree.
-                    if (isContainsField) {
-                        const cascade = buildOwnedCascade(removeTerm, `ucr_${suffix}_${ri}_`);
-                        deletePatterns.push(...cascade.deletePatterns);
-                        cascadeOptionals.push(...cascade.whereOptionals);
-                    }
-                });
-            }
-            if (setMod.add) {
-                for (const addItem of setMod.add) {
-                    if (addItem && typeof addItem === 'object' && 'shape' in addItem && 'fields' in addItem) {
-                        const nested = generateNodeDataTriples(addItem, options);
-                        insertPatterns.push(tripleOf(subjectTerm, propertyTerm, iriTerm(nested.uri)));
-                        insertPatterns.push(...nested.triples);
-                    }
-                    else {
-                        const terms = fieldValueToTerms(addItem, options);
-                        for (const term of terms) {
-                            insertPatterns.push(tripleOf(subjectTerm, propertyTerm, term));
-                        }
-                    }
-                }
-            }
-            continue;
-        }
-        // Non-set-modification replace of a `contains` property: cascade the old value's
-        // subtree (every branch below binds `old_${suffix}` in the WHERE).
-        if (isContainsField) {
-            containsOldVars.push(`old_${suffix}`);
-        }
-        // Unset (undefined/null) — delete only
-        if (field.value === undefined || field.value === null) {
-            const oldVar = varTerm(`old_${suffix}`);
-            deletePatterns.push(tripleOf(subjectTerm, propertyTerm, oldVar));
-            oldValueTriples.push(tripleOf(subjectTerm, propertyTerm, oldVar));
-            continue;
-        }
-        // Array overwrite — delete old values + insert new ones
-        if (Array.isArray(field.value)) {
-            const oldVar = varTerm(`old_${suffix}`);
-            deletePatterns.push(tripleOf(subjectTerm, propertyTerm, oldVar));
-            oldValueTriples.push(tripleOf(subjectTerm, propertyTerm, oldVar));
-            for (const item of field.value) {
-                if (item && typeof item === 'object' && 'shape' in item && 'fields' in item) {
-                    const nested = generateNodeDataTriples(item, options);
-                    insertPatterns.push(tripleOf(subjectTerm, propertyTerm, iriTerm(nested.uri)));
-                    insertPatterns.push(...nested.triples);
-                }
-                else {
-                    const terms = fieldValueToTerms(item, options);
-                    for (const term of terms) {
-                        insertPatterns.push(tripleOf(subjectTerm, propertyTerm, term));
-                    }
-                }
-            }
-            continue;
-        }
-        // Nested create (single object field)
-        if (typeof field.value === 'object' && 'shape' in field.value && 'fields' in field.value) {
-            const oldVar = varTerm(`old_${suffix}`);
-            deletePatterns.push(tripleOf(subjectTerm, propertyTerm, oldVar));
-            oldValueTriples.push(tripleOf(subjectTerm, propertyTerm, oldVar));
-            const nested = generateNodeDataTriples(field.value, options);
-            insertPatterns.push(tripleOf(subjectTerm, propertyTerm, iriTerm(nested.uri)));
-            insertPatterns.push(...nested.triples);
-            continue;
-        }
-        // IRExpression — computed value update (e.g. p.age.plus(1))
-        if (isIRExpression(field.value)) {
-            const expr = field.value;
-            const oldVar = varTerm(`old_${suffix}`);
-            const computedVarName = `computed_${suffix}`;
-            const computedVar = varTerm(computedVarName);
-            // DELETE old value
-            deletePatterns.push(tripleOf(subjectTerm, propertyTerm, oldVar));
-            // WHERE: OPTIONAL for old value
-            oldValueTriples.push(tripleOf(subjectTerm, propertyTerm, oldVar));
-            // Discover additional property references in the expression and add OPTIONAL triples
-            const registry = new VariableRegistry();
-            const mutationSubjectAlias = '__mutation_subject__';
-            // Pre-register the subject variable mapping for the field being updated
-            registry.set(mutationSubjectAlias, field.property, `old_${suffix}`);
-            const additionalOptionals = [];
-            processExpressionForProperties(expr, registry, additionalOptionals);
-            // Add any additional property OPTIONAL triples (for refs to other properties)
-            for (const triple of additionalOptionals) {
-                // Rewrite the subject from the placeholder variable to the actual subject term
-                if (triple.subject.kind === 'variable' && triple.subject.name === mutationSubjectAlias) {
-                    oldValueTriples.push(tripleOf(subjectTerm, triple.predicate, triple.object));
-                }
-                else {
-                    oldValueTriples.push(triple);
-                }
-            }
-            // Convert IRExpression to SparqlExpression
-            const sparqlExpr = convertExpression(expr, registry, additionalOptionals);
-            // BIND computed expression
-            extends_.push({ variable: computedVarName, expression: sparqlExpr });
-            // INSERT computed value
-            insertPatterns.push(tripleOf(subjectTerm, propertyTerm, computedVar));
-            continue;
-        }
-        // Simple value update — delete old + insert new
-        const oldVar = varTerm(`old_${suffix}`);
-        deletePatterns.push(tripleOf(subjectTerm, propertyTerm, oldVar));
-        oldValueTriples.push(tripleOf(subjectTerm, propertyTerm, oldVar));
-        const terms = fieldValueToTerms(field.value, options);
-        for (const term of terms) {
-            insertPatterns.push(tripleOf(subjectTerm, propertyTerm, term));
-        }
-    }
-    // Append cascade for each replaced `contains` property's old value.
-    containsOldVars.forEach((oldVar, n) => {
-        const cascade = buildOwnedCascade(varTerm(oldVar), `uc${n}_`);
-        deletePatterns.push(...cascade.deletePatterns);
-        cascadeOptionals.push(...cascade.whereOptionals);
-    });
-    return {
-        deletePatterns,
-        insertPatterns,
-        oldValueTriples,
-        extends: extends_,
-        cascadeOptionals,
-    };
-}
-/**
- * Wraps old-value triples in OPTIONAL (LEFT JOIN) so UPDATE succeeds
- * even when the old value doesn't exist.
- */
-function wrapOldValueOptionals(base, oldValueTriples) {
-    let algebra = base;
-    if (oldValueTriples.length === 0) {
-        return algebra;
-    }
-    for (const triple of oldValueTriples) {
-        algebra = {
-            type: 'left_join',
-            left: algebra,
-            right: { type: 'bgp', triples: [triple] },
-        };
-    }
-    return algebra;
-}
-/**
- * Converts an IRUpdateMutation to a SparqlDeleteInsertPlan.
- */
-function updateToAlgebra(query, options) {
-    var _a, _b, _c;
-    const subjectTerm = iriTerm(query.id);
-    const result = processUpdateFields(query.data, subjectTerm, options);
-    // Partition old-value/optional triples into subject-anchored ones and those
-    // anchored on a traversal target variable (e.g. `?a1 <name> ?a1_name` from a
-    // `p.bestFriend.name.ucase()` expression). Traversal-anchored triples MUST be
-    // nested inside the same OPTIONAL group as their traversal edge — otherwise,
-    // when the subject has no such edge, the leaf variable is unbound and the
-    // property triple matches every entity in the graph (data-corruption bug).
-    const travTos = new Set(((_a = query.traversalPatterns) !== null && _a !== void 0 ? _a : []).map((t) => t.to));
-    const travAnchoredByTo = new Map();
-    const subjectAnchored = [];
-    for (const triple of result.oldValueTriples) {
-        if (triple.subject.kind === 'variable' && travTos.has(triple.subject.name)) {
-            const list = (_b = travAnchoredByTo.get(triple.subject.name)) !== null && _b !== void 0 ? _b : [];
-            list.push(triple);
-            travAnchoredByTo.set(triple.subject.name, list);
-        }
-        else {
-            subjectAnchored.push(triple);
-        }
-    }
-    let whereAlgebra = wrapOldValueOptionals({ type: 'bgp', triples: [] }, subjectAnchored);
-    // Add traversal OPTIONAL patterns (for multi-segment expression refs). The
-    // traversal edge and its dependent leaf property triples share one OPTIONAL
-    // group so the leaf variable is scoped to the traversal target. These come
-    // BEFORE expression BINDs since the BINDs reference the traversal variables.
-    if (query.traversalPatterns) {
-        for (const trav of query.traversalPatterns) {
-            const fromTerm = trav.from === '__mutation_subject__' ? subjectTerm : varTerm(trav.from);
-            const traversalTriple = tripleOf(fromTerm, iriTerm(trav.property), varTerm(trav.to));
-            // The traversal edge binds the target var; each dependent leaf property is
-            // a nested OPTIONAL *within* that scope, so a missing optional property
-            // (e.g. a bestFriend with no hobby) doesn't drop the whole group, while an
-            // absent edge still leaves every leaf var unbound (no cross-entity match).
-            let travNode = { type: 'bgp', triples: [traversalTriple] };
-            for (const leaf of (_c = travAnchoredByTo.get(trav.to)) !== null && _c !== void 0 ? _c : []) {
-                travNode = {
-                    type: 'left_join',
-                    left: travNode,
-                    right: { type: 'bgp', triples: [leaf] },
-                };
-            }
-            whereAlgebra = { type: 'left_join', left: whereAlgebra, right: travNode };
-        }
-    }
-    // Owned-subtree cascade OPTIONALs for replaced `contains` properties.
-    for (const optional of result.cascadeOptionals) {
-        whereAlgebra = { type: 'left_join', left: whereAlgebra, right: optional };
-    }
-    // Add BIND expressions for computed fields
-    for (const ext of result.extends) {
-        whereAlgebra = {
-            type: 'extend',
-            inner: whereAlgebra,
-            variable: ext.variable,
-            expression: ext.expression,
-        };
-    }
-    return {
-        type: 'delete_insert',
-        deletePatterns: result.deletePatterns,
-        insertPatterns: result.insertPatterns,
-        whereAlgebra,
-    };
-}
-// ---------------------------------------------------------------------------
-// Owned-subtree cascade
-//
-// Composition cleanup driven by two declarative flags:
-//   - a property marked `contains` → the cascade FOLLOWS that edge,
-//   - a shape marked `dependent`   → its instances may be DELETED when reached.
-// Both are read from the live registry, so no vocabulary is hardcoded. From a root
-// node we follow `(c1|c2|…)+` over all contains predicates and, for each dependent
-// targetClass, wildcard-delete the reached typed nodes. Requiring an asserted
-// `?owned a <dependentType>` naturally excludes shared predicate IRIs (e.g. a simple
-// `sh:path`) and `rdf:nil` (never typed), so only owned structural nodes are removed.
-// ---------------------------------------------------------------------------
-/** True when the shape (or an ancestor) declares at least one `contains` property. */
-function shapeHasContainsProperty(shapeId) {
-    var _a;
-    const nodeShape = (_a = (0, ShapeClass_js_1.getShapeClass)(shapeId)) === null || _a === void 0 ? void 0 : _a.shape;
-    if (!nodeShape || typeof nodeShape.getPropertyShapes !== 'function')
-        return false;
-    return nodeShape
-        .getPropertyShapes(true)
-        .some((ps) => ps.contains);
-}
-// Memoized registry scan for cascade lowering — called once per update/delete and
-// again per owned-cascade item inside loops. Guarded by registry size (same rationale
-// as predicateTermCache). Callers treat the result as read-only.
-let containmentCache = null;
-let containmentCacheSize = -1;
-/** Gather contains-predicate IRIs and dependent targetClass IRIs from the registry. */
-function collectContainment() {
-    var _a;
-    const shapeClasses = (0, ShapeClass_js_1.getAllShapeClasses)();
-    if (containmentCache && shapeClasses.size === containmentCacheSize) {
-        return containmentCache;
-    }
-    const containsPreds = new Set();
-    const dependentTypes = new Set();
-    for (const [, shapeClass] of shapeClasses) {
-        const nodeShape = shapeClass === null || shapeClass === void 0 ? void 0 : shapeClass.shape;
-        if (!nodeShape)
-            continue;
-        if (nodeShape.dependent && ((_a = nodeShape.targetClass) === null || _a === void 0 ? void 0 : _a.id)) {
-            dependentTypes.add(nodeShape.targetClass.id);
-        }
-        const propertyShapes = typeof nodeShape.getPropertyShapes === 'function'
-            ? nodeShape.getPropertyShapes(false)
-            : [];
-        for (const ps of propertyShapes) {
-            if (ps.contains) {
-                const predId = (0, normalizePropertyPath_js_1.getSimplePathId)(ps.path);
-                if (predId)
-                    containsPreds.add(predId);
-            }
-        }
-    }
-    containmentCache = { containsPreds: [...containsPreds], dependentTypes: [...dependentTypes] };
-    containmentCacheSize = shapeClasses.size;
-    return containmentCache;
-}
-/**
- * Build DELETE patterns + WHERE OPTIONAL blocks that cascade-delete the owned subtree
- * reachable from `rootTerm` via `contains` edges. `varPrefix` keeps generated variables
- * unique across multiple roots in one query. Returns empty when nothing is owned.
- */
-function buildOwnedCascade(rootTerm, varPrefix) {
-    const { containsPreds, dependentTypes } = collectContainment();
-    if (containsPreds.length === 0 || dependentTypes.length === 0) {
-        return { deletePatterns: [], whereOptionals: [] };
-    }
-    // (c1|c2|…)+  — follow one-or-more contains edges from the root.
-    const pathExpr = containsPreds.length === 1
-        ? { oneOrMore: { id: containsPreds[0] } }
-        : { oneOrMore: { alt: containsPreds.map((id) => ({ id })) } };
-    const pathTerm = {
-        kind: 'path',
-        value: (0, pathExprToSparql_js_1.pathExprToSparql)(pathExpr),
-        uris: (0, pathExprToSparql_js_1.collectPathUris)(pathExpr),
-    };
-    const deletePatterns = [];
-    const whereOptionals = [];
-    dependentTypes.forEach((typeId, i) => {
-        const owned = varTerm(`${varPrefix}own${i}`);
-        const p = varTerm(`${varPrefix}op${i}`);
-        const o = varTerm(`${varPrefix}ov${i}`);
-        deletePatterns.push(tripleOf(owned, p, o));
-        whereOptionals.push({
-            type: 'bgp',
-            triples: [
-                tripleOf(rootTerm, pathTerm, owned),
-                tripleOf(owned, iriTerm(RDF_TYPE), iriTerm(typeId)),
-                tripleOf(owned, p, o),
-            ],
-        });
-    });
-    return { deletePatterns, whereOptionals };
-}
-/**
- * Converts an IRDeleteMutation to a SparqlDeleteInsertPlan (DELETE + WHERE).
- */
-function deleteToAlgebra(query, _options) {
-    const deletePatterns = [];
-    const requiredTriples = [];
-    const optionalTriples = [];
-    const cascadeOptionals = [];
-    for (let i = 0; i < query.ids.length; i++) {
-        const subjectTerm = iriTerm(query.ids[i].id);
-        const idx = query.ids.length > 1 ? `_${i}` : '';
-        const subjWild = tripleOf(subjectTerm, varTerm(`p${idx}`), varTerm(`o${idx}`));
-        const objWild = tripleOf(varTerm(`s${idx}`), varTerm(`p2${idx}`), subjectTerm);
-        const typeGuard = tripleOf(subjectTerm, iriTerm(RDF_TYPE), iriTerm(resolveShapeScanIri(query.shape)));
-        // DELETE block: all patterns (subject-wildcard, object-wildcard, type)
-        deletePatterns.push(subjWild, objWild, typeGuard);
-        // WHERE block: subject-wildcard and type guard are required;
-        // object-wildcard is OPTIONAL (entity may have no incoming references)
-        requiredTriples.push(subjWild, typeGuard);
-        optionalTriples.push(objWild);
-        // Cascade-delete the owned subtree — only for shapes that actually own something
-        // (have a `contains` property); a plain entity delete is left untouched.
-        if (shapeHasContainsProperty(query.shape)) {
-            const cascade = buildOwnedCascade(subjectTerm, `c${idx}_`);
-            deletePatterns.push(...cascade.deletePatterns);
-            cascadeOptionals.push(...cascade.whereOptionals);
-        }
-    }
-    // Build WHERE algebra: required BGP + OPTIONAL for each object-wildcard + cascade OPTIONALs
-    let whereAlgebra = { type: 'bgp', triples: requiredTriples };
-    for (const triple of optionalTriples) {
-        whereAlgebra = {
-            type: 'left_join',
-            left: whereAlgebra,
-            right: { type: 'bgp', triples: [triple] },
-        };
-    }
-    for (const optional of cascadeOptionals) {
-        whereAlgebra = { type: 'left_join', left: whereAlgebra, right: optional };
-    }
-    return {
-        type: 'delete_insert',
-        deletePatterns,
-        insertPatterns: [],
-        whereAlgebra,
-    };
-}
-// ---------------------------------------------------------------------------
-// Blank node tree walking for schema-aware delete cleanup
-// ---------------------------------------------------------------------------
-/**
- * Checks whether a PropertyShape points to blank nodes (sh:BlankNode or
- * sh:BlankNodeOrIRI). Returns true when the property's range *may* include
- * blank node values that should be cleaned up on delete.
- */
-function isBlankNodeProperty(prop) {
-    var _a;
-    const nk = (_a = prop.nodeKind) === null || _a === void 0 ? void 0 : _a.id;
-    if (!nk)
-        return false;
-    return nk === shacl_js_1.shacl.BlankNode.id || nk === shacl_js_1.shacl.BlankNodeOrIRI.id;
-}
-/**
- * Recursively builds DELETE + WHERE patterns for blank-node-typed properties.
- *
- * For each blank-node property on the shape:
- * - DELETE: `?bnVar ?pN ?oN .`  (wildcard all triples on the blank node)
- * - WHERE: `OPTIONAL { ?parent <property> ?bnVar . FILTER(isBlank(?bnVar)) . ?bnVar ?pN ?oN . }`
- *
- * Recurses into the property's valueShape to handle nested blank nodes
- * (e.g. Person → Address (blank) → GeoPoint (blank)).
- */
-function walkBlankNodeTree(shapeId, parentVar, depth, deletePatterns) {
-    var _a;
-    const shapeClass = (0, ShapeClass_js_1.getShapeClass)(shapeId);
-    if (!(shapeClass === null || shapeClass === void 0 ? void 0 : shapeClass.shape))
-        return null;
-    let optionals = null;
-    const props = shapeClass.shape.getPropertyShapes(true);
-    for (const prop of props) {
-        if (!isBlankNodeProperty(prop))
-            continue;
-        const bnVar = `bn${depth}`;
-        const pVar = `p${depth}`;
-        const oVar = `o${depth}`;
-        // DELETE pattern: wildcard all triples on the blank node
-        deletePatterns.push(tripleOf(varTerm(bnVar), varTerm(pVar), varTerm(oVar)));
-        // WHERE: parent --<property>--> ?bnVar
-        const traverseTriple = tripleOf(varTerm(parentVar), resolvePropertyPredicateTerm(prop.id), varTerm(bnVar));
-        // FILTER(isBlank(?bnVar))
-        const isBlankFilter = {
-            kind: 'function_expr',
-            name: 'isBlank',
-            args: [{ kind: 'variable_expr', name: bnVar }],
-        };
-        // ?bnVar ?pN ?oN
-        const wildcardTriple = tripleOf(varTerm(bnVar), varTerm(pVar), varTerm(oVar));
-        // Build inner pattern: traverse + filter + wildcard
-        let innerPattern = {
-            type: 'bgp',
-            triples: [traverseTriple, wildcardTriple],
-        };
-        innerPattern = { type: 'filter', expression: isBlankFilter, inner: innerPattern };
-        // Recurse into valueShape for nested blank nodes
-        if ((_a = prop.valueShape) === null || _a === void 0 ? void 0 : _a.id) {
-            const nestedOptional = walkBlankNodeTree(prop.valueShape.id, bnVar, depth + 1, deletePatterns);
-            if (nestedOptional) {
-                innerPattern = { type: 'left_join', left: innerPattern, right: nestedOptional };
-            }
-        }
-        // Wrap in OPTIONAL (left_join)
-        if (optionals) {
-            optionals = { type: 'left_join', left: optionals, right: innerPattern };
-        }
-        else {
-            optionals = innerPattern;
-        }
-        depth++;
-    }
-    return optionals;
-}
-/**
- * Converts an IRDeleteAllMutation to a SparqlDeleteInsertPlan.
- *
- * Generates DELETE { ?a0 ?p ?o . [blank node wildcards] }
- *          WHERE  { ?a0 a <Shape> . ?a0 ?p ?o . OPTIONAL { [blank node traversals] } }
- */
-function deleteAllToAlgebra(query, _options) {
-    const subjectVar = 'a0';
-    // DELETE patterns: root wildcard
-    const deletePatterns = [
-        tripleOf(varTerm(subjectVar), varTerm('p'), varTerm('o')),
-    ];
-    // WHERE: type triple + root wildcard
-    const typeTriple = tripleOf(varTerm(subjectVar), iriTerm(RDF_TYPE), iriTerm(resolveShapeScanIri(query.shape)));
-    const rootWildcard = tripleOf(varTerm(subjectVar), varTerm('p'), varTerm('o'));
-    let whereAlgebra = { type: 'bgp', triples: [typeTriple, rootWildcard] };
-    // Walk blank node tree for cleanup
-    const blankNodeOptional = walkBlankNodeTree(query.shape, subjectVar, 1, deletePatterns);
-    if (blankNodeOptional) {
-        whereAlgebra = { type: 'left_join', left: whereAlgebra, right: blankNodeOptional };
-    }
-    return {
-        type: 'delete_insert',
-        deletePatterns,
-        insertPatterns: [],
-        whereAlgebra,
-    };
-}
-/**
- * Converts an IRDeleteWhereMutation to a SparqlDeleteInsertPlan.
- *
- * Like deleteAllToAlgebra but adds filter conditions from the where clause.
- */
-function deleteWhereToAlgebra(query, _options) {
-    const subjectVar = 'a0';
-    const registry = new VariableRegistry();
-    // DELETE patterns: root wildcard
-    const deletePatterns = [
-        tripleOf(varTerm(subjectVar), varTerm('p'), varTerm('o')),
-    ];
-    // WHERE: type triple + root wildcard
-    const typeTriple = tripleOf(varTerm(subjectVar), iriTerm(RDF_TYPE), iriTerm(resolveShapeScanIri(query.shape)));
-    const rootWildcard = tripleOf(varTerm(subjectVar), varTerm('p'), varTerm('o'));
-    let whereAlgebra = { type: 'bgp', triples: [typeTriple, rootWildcard] };
-    // Process where patterns (traversals from the where clause)
-    const traverseTriples = [];
-    const optionalPropertyTriples = [];
-    for (const pattern of query.wherePatterns) {
-        processPattern(pattern, registry, traverseTriples, optionalPropertyTriples);
-    }
-    // Add traverse triples to required BGP
-    if (traverseTriples.length > 0) {
-        whereAlgebra = joinNodes(whereAlgebra, { type: 'bgp', triples: traverseTriples });
-    }
-    // Process expression to discover property triples
-    processExpressionForProperties(query.where, registry, optionalPropertyTriples);
-    // Add optional property triples
-    for (const triple of optionalPropertyTriples) {
-        whereAlgebra = joinNodes(whereAlgebra, { type: 'bgp', triples: [triple] });
-    }
-    // Convert and add filter expression
-    const filterExpr = convertExpression(query.where, registry, []);
-    whereAlgebra = { type: 'filter', expression: filterExpr, inner: whereAlgebra };
-    // Walk blank node tree for cleanup
-    const blankNodeOptional = walkBlankNodeTree(query.shape, subjectVar, 1, deletePatterns);
-    if (blankNodeOptional) {
-        whereAlgebra = { type: 'left_join', left: whereAlgebra, right: blankNodeOptional };
-    }
-    return {
-        type: 'delete_insert',
-        deletePatterns,
-        insertPatterns: [],
-        whereAlgebra,
-    };
-}
-/**
- * Converts an IRUpdateWhereMutation to a SparqlDeleteInsertPlan.
- *
- * Like updateToAlgebra but uses a variable subject (?a0) instead of a
- * hardcoded entity IRI, adds a type triple, and optionally includes
- * filter conditions from the where clause.
- */
-function updateWhereToAlgebra(query, options) {
-    const subjectTerm = varTerm('a0');
-    const result = processUpdateFields(query.data, subjectTerm, options);
-    // WHERE: type triple is always required
-    const typeTriple = tripleOf(subjectTerm, iriTerm(RDF_TYPE), iriTerm(resolveShapeScanIri(query.data.shape)));
-    let whereAlgebra = { type: 'bgp', triples: [typeTriple] };
-    // Process where filter conditions (if any)
-    if (query.where && query.wherePatterns) {
-        const registry = new VariableRegistry();
-        const traverseTriples = [];
-        const optionalPropertyTriples = [];
-        for (const pattern of query.wherePatterns) {
-            processPattern(pattern, registry, traverseTriples, optionalPropertyTriples);
-        }
-        if (traverseTriples.length > 0) {
-            whereAlgebra = joinNodes(whereAlgebra, { type: 'bgp', triples: traverseTriples });
-        }
-        processExpressionForProperties(query.where, registry, optionalPropertyTriples);
-        for (const triple of optionalPropertyTriples) {
-            whereAlgebra = joinNodes(whereAlgebra, { type: 'bgp', triples: [triple] });
-        }
-        const filterExpr = convertExpression(query.where, registry, []);
-        whereAlgebra = { type: 'filter', expression: filterExpr, inner: whereAlgebra };
-    }
-    whereAlgebra = wrapOldValueOptionals(whereAlgebra, result.oldValueTriples);
-    // Add traversal OPTIONAL patterns (for multi-segment expression refs)
-    // These must come BEFORE expression BINDs since the BINDs reference traversal variables.
-    if (query.traversalPatterns) {
-        for (const trav of query.traversalPatterns) {
-            const fromTerm = trav.from === '__mutation_subject__' ? varTerm('a0') : varTerm(trav.from);
-            const traversalTriple = tripleOf(fromTerm, iriTerm(trav.property), varTerm(trav.to));
-            whereAlgebra = {
-                type: 'left_join',
-                left: whereAlgebra,
-                right: { type: 'bgp', triples: [traversalTriple] },
-            };
-        }
-    }
-    // Owned-subtree cascade OPTIONALs for replaced `contains` properties.
-    for (const optional of result.cascadeOptionals) {
-        whereAlgebra = { type: 'left_join', left: whereAlgebra, right: optional };
-    }
-    // Add BIND expressions for computed fields
-    for (const ext of result.extends) {
-        whereAlgebra = {
-            type: 'extend',
-            inner: whereAlgebra,
-            variable: ext.variable,
-            expression: ext.expression,
-        };
-    }
-    return {
-        type: 'delete_insert',
-        deletePatterns: result.deletePatterns,
-        insertPatterns: result.insertPatterns,
-        whereAlgebra,
-    };
-}
-// ---------------------------------------------------------------------------
-// Convenience wrappers: IR → algebra → SPARQL string in one call
-// ---------------------------------------------------------------------------
-/**
- * Converts an IRSelectQuery to a SPARQL string.
- */
-function selectToSparql(query, options) {
-    const plan = selectToAlgebra(query, options);
-    return (0, algebraToString_js_1.selectPlanToSparql)(plan, options);
-}
-/**
- * Converts an IRCreateMutation to a SPARQL string.
- * Stub: will be implemented when algebraToString is available.
- */
-function createToSparql(query, options) {
-    const plan = createToAlgebra(query, options);
-    return (0, algebraToString_js_1.insertDataPlanToSparql)(plan, options);
-}
-/**
- * Converts an IRUpdateMutation to a SPARQL string.
- * Stub: will be implemented when algebraToString is available.
- */
-function updateToSparql(query, options) {
-    const plan = updateToAlgebra(query, options);
-    return (0, algebraToString_js_1.deleteInsertPlanToSparql)(plan, options);
-}
-/**
- * Converts an IRDeleteMutation to a SPARQL string.
- */
-function deleteToSparql(query, options) {
-    const plan = deleteToAlgebra(query, options);
-    return (0, algebraToString_js_1.deleteInsertPlanToSparql)(plan, options);
-}
-/**
- * Converts an IRDeleteAllMutation to a SPARQL string.
- */
-function deleteAllToSparql(query, options) {
-    const plan = deleteAllToAlgebra(query, options);
-    return (0, algebraToString_js_1.deleteInsertPlanToSparql)(plan, options);
-}
-/**
- * Converts an IRDeleteWhereMutation to a SPARQL string.
- */
-function deleteWhereToSparql(query, options) {
-    const plan = deleteWhereToAlgebra(query, options);
-    return (0, algebraToString_js_1.deleteInsertPlanToSparql)(plan, options);
-}
-/**
- * Converts an IRUpdateWhereMutation to a SPARQL string.
- */
-function updateWhereToSparql(query, options) {
-    const plan = updateWhereToAlgebra(query, options);
-    return (0, algebraToString_js_1.deleteInsertPlanToSparql)(plan, options);
-}
-//# sourceMappingURL=irToAlgebra.js.map